/*
 * Copyright Codeplay Software Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use these files except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// DO NOT MODIFY BY HAND
// This file was automatically generated by generate_conv2d_tests.py.
// Results calculated using Tensorflow v1.12.0.

#include <gtest/gtest.h>

#include "sycldnn/padding_mode.h"

#include "test/types/cartesian_product.h"
#include "test/types/kernel_data_types.h"
#include "test/types/nested_pairs_to_triple.h"
#include "test/types/test_backend_types.h"
#include "test/types/to_gtest_types.h"

#include "test/conv2d/selector_list.h"
#include "test/conv2d/window_stride_fixture.h"

#include <array>
#include <vector>

using DataTypeList = sycldnn::types::KernelDataTypes;
using Selectors = sycldnn::types::SelectorList;
using Backends = sycldnn::types::AllBackendTypes;

using SNNTypePairs =
    sycldnn::types::CartesianProduct<Selectors, DataTypeList>::type;
using BackendTypePairs =
    sycldnn::types::CartesianProduct<SNNTypePairs, Backends>::type;
using TestTriples = sycldnn::types::NestedPairsToTriple<BackendTypePairs>::type;

using GTestTypeTriples = sycldnn::types::ToGTestTypes<TestTriples>::type;

template <typename Pair>
using InputBackpropWindow3Stride1 = WindowStrideTest<Pair, 3, 1>;
TYPED_TEST_SUITE(InputBackpropWindow3Stride1, GTestTypeTriples);
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {29.,  62.,  83.,  75.,  99.,  192.,
                                         237., 198., 207., 372., 417., 330.,
                                         263., 446., 485., 365.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  4.,  7.,  6.,  7.,  23.,
                                         33., 24., 19., 53., 63., 42.,
                                         21., 52., 59., 36.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      184.,  412.,  568.,  528.,  678.,  1347., 1689., 1434.,
      1494., 2715., 3057., 2442., 1968., 3352., 3652., 2760.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,   22.,  42.,  39.,  40.,  144.,
                                         216., 164., 124., 360., 432., 296.,
                                         149., 374., 426., 263.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1288.,  2972.,  4172.,  3944.,  4980.,  10038., 12702., 10884.,
      11316., 20694., 23358., 18756., 15208., 25964., 28316., 21448.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,  140.,  284.,  278.,  260.,  1000., 1544., 1204.,
      884., 2632., 3176., 2212., 1118., 2828., 3228., 2006.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      44.,  58.,  100., 124., 136., 166., 128., 150., 165., 198., 330.,
      384., 411., 474., 351., 396., 357., 414., 654., 744., 735., 834.,
      591., 660., 480., 526., 820., 892., 892., 970., 676., 730.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  5.,  8.,  11., 14.,  10.,  12.,  10.,  14.,  36.,
      46., 56., 66., 42., 48., 34.,  38.,  96.,  106., 116., 126.,
      78., 84., 39., 42., 97., 104., 111., 118., 68.,  72.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      288.,  392.,  686.,  866.,  962.,  1190., 928.,  1096.,
      1164., 1416., 2379., 2793., 3009., 3495., 2604., 2952.,
      2652., 3096., 4899., 5601., 5529., 6303., 4476., 5016.,
      3664., 4024., 6278., 6842., 6842., 7454., 5200., 5624.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  28.,  48.,  68.,  88.,  67.,  81.,  58.,  86.,  232.,
      304., 376., 448., 294., 338., 226., 254., 664., 736., 808., 880.,
      558., 602., 281., 303., 708., 760., 812., 864., 503., 533.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2056.,  2856.,  5044.,  6436.,  7204.,  8980.,  7048.,  8360.,
      8700.,  10668., 18006., 21246., 22974., 26790., 20028., 22764.,
      20412., 23916., 37878., 43422., 42846., 48966., 34812., 39084.,
      28616., 31464., 49108., 53572., 53572., 58420., 40776., 44136.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   180.,  324.,  468.,  612.,  486.,  590.,
      380.,  588.,  1640., 2184., 2728., 3272., 2188., 2524.,
      1628., 1836., 4904., 5448., 5992., 6536., 4204., 4540.,
      2126., 2294., 5396., 5796., 6196., 6596., 3862., 4094.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      74.,   88.,   102.,  116.,  176.,  200.,  224.,  248.,  242.,  272.,
      302.,  332.,  234.,  256.,  278.,  300.,  297.,  330.,  363.,  396.,
      606.,  660.,  714.,  768.,  759.,  822.,  885.,  948.,  657.,  702.,
      747.,  792.,  657.,  714.,  771.,  828.,  1218., 1308., 1398., 1488.,
      1371., 1470., 1569., 1668., 1113., 1182., 1251., 1320., 914.,  960.,
      1006., 1052., 1568., 1640., 1712., 1784., 1706., 1784., 1862., 1940.,
      1298., 1352., 1406., 1460.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   7.,   10.,  13.,  16.,  19.,  22.,  25.,
      28.,  18.,  20.,  22.,  24.,  16.,  20.,  24.,  28.,  62.,  72.,
      82.,  92.,  102., 112., 122., 132., 78.,  84.,  90.,  96.,  64.,
      68.,  72.,  76.,  182., 192., 202., 212., 222., 232., 242., 252.,
      150., 156., 162., 168., 75.,  78.,  81.,  84.,  187., 194., 201.,
      208., 215., 222., 229., 236., 132., 136., 140., 144.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      496.,   600.,   704.,   808.,   1234.,  1414.,  1594.,  1774.,
      1750.,  1978.,  2206.,  2434.,  1728.,  1896.,  2064.,  2232.,
      2136.,  2388.,  2640.,  2892.,  4443.,  4857.,  5271.,  5685.,
      5649.,  6135.,  6621.,  7107.,  4944.,  5292.,  5640.,  5988.,
      4968.,  5412.,  5856.,  6300.,  9267.,  9969.,  10671., 11373.,
      10473., 11247., 12021., 12795., 8544.,  9084.,  9624.,  10164.,
      7056.,  7416.,  7776.,  8136.,  12130., 12694., 13258., 13822.,
      13222., 13834., 14446., 15058., 10080., 10504., 10928., 11352.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    11.,   17.,   23.,   40.,   60.,   80.,   100.,  120.,  140.,
      160.,  180.,  123.,  137.,  151.,  165.,  94.,   122.,  150.,  178.,
      408.,  480.,  552.,  624.,  696.,  768.,  840.,  912.,  554.,  598.,
      642.,  686.,  430.,  458.,  486.,  514.,  1272., 1344., 1416., 1488.,
      1560., 1632., 1704., 1776., 1082., 1126., 1170., 1214., 545.,  567.,
      589.,  611.,  1376., 1428., 1480., 1532., 1584., 1636., 1688., 1740.,
      983.,  1013., 1043., 1073.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3592.,   4392.,   5192.,   5992.,   9188.,  10580., 11972.,  13364.,
      13268.,  15044.,  16820.,  18596.,  13256., 14568., 15880.,  17192.,
      16140.,  18108.,  20076.,  22044.,  33942., 37182., 40422.,  43662.,
      43518.,  47334.,  51150.,  54966.,  38316., 41052., 43788.,  46524.,
      38604.,  42108.,  45612.,  49116.,  72246., 77790., 83334.,  88878.,
      81822.,  87942.,  94062.,  100182., 66924., 71196., 75468.,  79740.,
      55432.,  58280.,  61128.,  63976.,  95396., 99860., 104324., 108788.,
      104084., 108932., 113780., 118628., 79432., 82792., 86152.,  89512.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    70.,    110.,   150.,   260.,   404.,   548.,   692.,
      836.,   980.,   1124.,  1268.,  902.,   1006.,  1110.,  1214.,
      620.,   828.,   1036.,  1244.,  2920.,  3464.,  4008.,  4552.,
      5096.,  5640.,  6184.,  6728.,  4156.,  4492.,  4828.,  5164.,
      3116.,  3324.,  3532.,  3740.,  9448.,  9992.,  10536., 11080.,
      11624., 12168., 12712., 13256., 8188.,  8524.,  8860.,  9196.,
      4142.,  4310.,  4478.,  4646.,  10532., 10932., 11332., 11732.,
      12132., 12532., 12932., 13332., 7574.,  7806.,  8038.,  8270.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      32.,  68.,  89.,  110., 96.,  114., 219., 264., 309., 252.,
      249., 444., 489., 534., 417., 320., 539., 578., 617., 460.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  4.,  10., 12.,  9.,  8.,   26.,
                                         56., 54., 36., 23.,  62., 119., 102.,
                                         63., 28., 67., 118., 93., 54.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      204.,  454.,  610.,  766.,  684.,  786.,  1545., 1887., 2229., 1842.,
      1806., 3255., 3597., 3939., 3102., 2404., 4066., 4366., 4666., 3492.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   22.,  59.,  78.,  61.,  46.,  164., 370., 372., 254.,
      154., 428., 838., 732., 458., 203., 490., 869., 690., 403.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1432.,  3284.,  4484.,  5684.,  5144.,  5796.,  11550.,
      14214., 16878., 14052., 13716., 24870., 27534., 30198.,
      23892., 18616., 31556., 33908., 36260., 27192.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   140.,  394.,  556.,  446.,  300.,  1144., 2660., 2744., 1900.,
      1116., 3160., 6260., 5528., 3484., 1542., 3740., 6658., 5308., 3110.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      48.,  64.,  109., 136.,  145.,  178.,  181.,  220.,  164., 192.,
      189., 228., 375., 438.,  456.,  528.,  537.,  618.,  447., 504.,
      429., 498., 780., 888.,  861.,  978.,  942.,  1068., 747., 834.,
      584., 640., 991., 1078., 1063., 1156., 1135., 1234., 852., 920.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  5.,   8.,   14.,  20.,  19.,  24.,  15.,  18.,
      11., 16., 40.,  52.,  91.,  112., 92.,  108., 63.,  72.,
      41., 46., 112., 124., 217., 238., 188., 204., 117., 126.,
      52., 56., 125., 134., 221., 236., 175., 186., 102., 108.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      316.,  436.,  752.,  956.,  1028., 1280., 1304., 1604., 1204., 1420.,
      1344., 1644., 2721., 3207., 3351., 3909., 3981., 4611., 3348., 3792.,
      3204., 3744., 5871., 6717., 6501., 7419., 7131., 8121., 5688., 6372.,
      4476., 4916., 7616., 8300., 8180., 8912., 8744., 9524., 6580., 7116.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  28.,  48.,  85.,   127.,  128.,  164.,  105., 127.,
      64.,  100., 260., 348., 620.,  776.,  652.,  772.,  456., 524.,
      280., 316., 788., 876., 1556., 1712., 1372., 1492., 864., 932.,
      383., 413., 928., 996., 1651., 1765., 1316., 1400., 771., 817.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2264.,  3192.,  5548.,  7132.,  7708.,  9676.,  9868.,  12220.,
      9208.,  10904., 10092., 12444., 20670., 24486., 25638., 30030.,
      30606., 35574., 25884., 29388., 24732., 29004., 45510., 52206.,
      50478., 57750., 55446., 63294., 44364., 49788., 35032., 38520.,
      59692., 65116., 64156., 69964., 68620., 74812., 51704., 55960.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   180.,  324.,  578.,   890.,   932.,   1204.,  782.,  950.,
      420.,  692.,  1848., 2520., 4540.,  5740.,  4888.,  5816.,  3460., 3988.,
      2052., 2324., 5880., 6552., 11740., 12940., 10456., 11384., 6628., 7156.,
      2934., 3166., 7140., 7668., 12746., 13634., 10196., 10852., 5990., 6350.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      80.,   96.,   112.,  128.,  191.,  218.,  245.,  272.,  257.,  290.,
      323.,  356.,  323.,  362.,  401.,  440.,  300.,  328.,  356.,  384.,
      339.,  378.,  417.,  456.,  687.,  750.,  813.,  876.,  840.,  912.,
      984.,  1056., 993.,  1074., 1155., 1236., 837.,  894.,  951.,  1008.,
      789.,  858.,  927.,  996.,  1452., 1560., 1668., 1776., 1605., 1722.,
      1839., 1956., 1758., 1884., 2010., 2136., 1407., 1494., 1581., 1668.,
      1112., 1168., 1224., 1280., 1895., 1982., 2069., 2156., 2033., 2126.,
      2219., 2312., 2171., 2270., 2369., 2468., 1636., 1704., 1772., 1840.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   7.,   10.,  13.,  16.,  22.,  28.,  34.,  40.,
      33.,  38.,  43.,  48.,  27.,  30.,  33.,  36.,  17.,  22.,  27.,  32.,
      68.,  80.,  92.,  104., 161., 182., 203., 224., 168., 184., 200., 216.,
      117., 126., 135., 144., 77.,  82.,  87.,  92.,  212., 224., 236., 248.,
      413., 434., 455., 476., 360., 376., 392., 408., 225., 234., 243., 252.,
      100., 104., 108., 112., 241., 250., 259., 268., 427., 442., 457., 472.,
      339., 350., 361., 372., 198., 204., 210., 216.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      540.,   660.,   780.,   900.,   1348.,  1552.,  1756.,  1960.,  1864.,
      2116.,  2368.,  2620.,  2380.,  2680.,  2980.,  3280.,  2244.,  2460.,
      2676.,  2892.,  2460.,  2760.,  3060.,  3360.,  5073.,  5559.,  6045.,
      6531.,  6279.,  6837.,  7395.,  7953.,  7485.,  8115.,  8745.,  9375.,
      6360.,  6804.,  7248.,  7692.,  6000.,  6540.,  7080.,  7620.,  11103.,
      11949., 12795., 13641., 12309., 13227., 14145., 15063., 13515., 14505.,
      15495., 16485., 10860., 11544., 12228., 12912., 8620.,  9060.,  9500.,
      9940.,  14716., 15400., 16084., 16768., 15808., 16540., 17272., 18004.,
      16900., 17680., 18460., 19240., 12756., 13292., 13828., 14364.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    11.,   17.,   23.,   40.,   60.,   80.,   100.,  137.,  179.,
      221.,  263.,  228.,  264.,  300.,  336.,  193.,  215.,  237.,  259.,
      100.,  136.,  172.,  208.,  452.,  540.,  628.,  716.,  1120., 1276.,
      1432., 1588., 1212., 1332., 1452., 1572., 860.,  928.,  996.,  1064.,
      532.,  568.,  604.,  640.,  1508., 1596., 1684., 1772., 2992., 3148.,
      3304., 3460., 2652., 2772., 2892., 3012., 1676., 1744., 1812., 1880.,
      743.,  773.,  803.,  833.,  1804., 1872., 1940., 2008., 3215., 3329.,
      3443., 3557., 2568., 2652., 2736., 2820., 1507., 1553., 1599., 1645.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3928.,   4856.,   5784.,   6712.,   10076.,  11660.,  13244.,  14828.,
      14156.,  16124.,  18092.,  20060.,  18236.,  20588.,  22940.,  25292.,
      17336.,  19032.,  20728.,  22424.,  18684.,  21036.,  23388.,  25740.,
      38910.,  42726.,  46542.,  50358.,  48486.,  52878.,  57270.,  61662.,
      58062.,  63030.,  67998.,  72966.,  49548.,  53052.,  56556.,  60060.,
      46764.,  51036.,  55308.,  59580.,  86790.,  93486.,  100182., 106878.,
      96366.,  103638., 110910., 118182., 105942., 113790., 121638., 129486.,
      85308.,  90732.,  96156.,  101580., 67864.,  71352.,  74840.,  78328.,
      115964., 121388., 126812., 132236., 124652., 130460., 136268., 142076.,
      133340., 139532., 145724., 151916., 100728., 104984., 109240., 113496.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    70.,    110.,   150.,   260.,   404.,   548.,   692.,   946.,
      1258.,  1570.,  1882.,  1684.,  1956.,  2228.,  2500.,  1454.,  1622.,
      1790.,  1958.,  660.,   932.,   1204.,  1476.,  3256.,  3928.,  4600.,
      5272.,  8300.,  9500.,  10700., 11900., 9176.,  10104., 11032., 11960.,
      6580.,  7108.,  7636.,  8164.,  3924.,  4196.,  4468.,  4740.,  11320.,
      11992., 12664., 13336., 22700., 23900., 25100., 26300., 20312., 21240.,
      22168., 23096., 12916., 13444., 13972., 14500., 5718.,  5950.,  6182.,
      6414.,  13940., 14468., 14996., 15524., 24922., 25810., 26698., 27586.,
      19972., 20628., 21284., 21940., 11750., 12110., 12470., 12830.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      35.,  74.,  95.,  116., 137., 117., 129., 246., 291., 336., 381., 306.,
      291., 516., 561., 606., 651., 504., 377., 632., 671., 710., 749., 555.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,  10.,  16.,  17.,  12., 9.,  29., 62.,  83.,  75.,  48.,
      27., 71., 134., 173., 141., 84., 35., 82., 142., 166., 127., 72.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      224.,  496.,  652.,  808.,  964.,  840.,  894.,  1743.,
      2085., 2427., 2769., 2250., 2118., 3795., 4137., 4479.,
      4821., 3762., 2840., 4780., 5080., 5380., 5680., 4224.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,   22.,  59.,   101.,  114.,  83.,
                                         52.,  184., 412.,  568.,  528.,  344.,
                                         184., 496., 952.,  1252., 1032., 620.,
                                         257., 606., 1055., 1241., 954.,  543.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1576.,  3596.,  4796.,  5996.,  7196.,  6344.,  6612.,  13062.,
      15726., 18390., 21054., 17220., 16116., 29046., 31710., 34374.,
      37038., 29028., 22024., 37148., 39500., 41852., 44204., 32936.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   140.,  394.,  706.,  828.,  614.,  340.,  1288.,
      2972., 4172., 3944., 2596., 1348., 3688., 7148., 9500.,
      7880., 4756., 1966., 4652., 8122., 9586., 7388., 4214.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      52.,   70.,   118.,  148.,  154.,  190.,  190.,  232.,  226.,  274.,
      200.,  234.,  213.,  258.,  420.,  492.,  501.,  582.,  582.,  672.,
      663.,  762.,  543.,  612.,  501.,  582.,  906.,  1032., 987.,  1122.,
      1068., 1212., 1149., 1302., 903.,  1008., 688.,  754.,  1162., 1264.,
      1234., 1342., 1306., 1420., 1378., 1498., 1028., 1110.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  2.,  5.,   8.,   14.,  20.,  23.,  32.,  27.,  34.,  20.,  24.,
      12., 18., 44.,  58.,  100., 124., 136., 166., 128., 150., 84.,  96.,
      48., 54., 128., 142., 244., 268., 316., 346., 260., 282., 156., 168.,
      65., 70., 153., 164., 266., 284., 311., 332., 239., 254., 136., 144.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      344.,  480.,   818.,   1046.,  1094.,  1370.,  1370., 1694., 1646., 2018.,
      1480., 1744.,  1524.,  1872.,  3063.,  3621.,  3693., 4323., 4323., 5025.,
      4953., 5727.,  4092.,  4632.,  3756.,  4392.,  6843., 7833., 7473., 8535.,
      8103., 9237.,  8733.,  9939.,  6900.,  7728.,  5288., 5808., 8954., 9758.,
      9518., 10370., 10082., 10982., 10646., 11594., 7960., 8608.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    11.,   28.,   48.,   85.,   127.,  151.,  217.,  188.,  240.,
      143.,  173.,  70.,   114.,  288.,  392.,  686.,  866.,  962.,  1190.,
      928.,  1096., 618.,  710.,  334.,  378.,  912.,  1016., 1766., 1946.,
      2330., 2558., 1936., 2104., 1170., 1262., 485.,  523.,  1148., 1232.,
      2005., 2143., 2359., 2521., 1820., 1936., 1039., 1101.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2472.,  3528.,  6052.,  7828.,  8212.,  10372., 10372., 12916.,
      12532., 15460., 11368., 13448., 11484., 14220., 23334., 27726.,
      28302., 33270., 33270., 38814., 38238., 44358., 31740., 36012.,
      29052., 34092., 53142., 60990., 58110., 66534., 63078., 72078.,
      68046., 77622., 53916., 60492., 41448., 45576., 70276., 76660.,
      74740., 81508., 79204., 86356., 83668., 91204., 62632., 67784.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    70.,    180.,   324.,   578.,   890.,   1082.,  1586.,
      1396.,  1796.,  1078.,  1310.,  460.,   796.,   2056.,  2856.,
      5044.,  6436.,  7204.,  8980.,  7048.,  8360.,  4732.,  5452.,
      2476.,  2812.,  6856.,  7656.,  13396., 14788., 17860., 19636.,
      14920., 16232., 9052.,  9772.,  3742.,  4038.,  8884.,  9540.,
      15554., 16634., 18362., 19634., 14196., 15108., 8118.,  8606.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      86.,   104.,  122.,  140.,  206.,  236.,  266.,  296.,  272.,  308.,
      344.,  380.,  338.,  380.,  422.,  464.,  404.,  452.,  500.,  548.,
      366.,  400.,  434.,  468.,  381.,  426.,  471.,  516.,  768.,  840.,
      912.,  984.,  921.,  1002., 1083., 1164., 1074., 1164., 1254., 1344.,
      1227., 1326., 1425., 1524., 1017., 1086., 1155., 1224., 921.,  1002.,
      1083., 1164., 1686., 1812., 1938., 2064., 1839., 1974., 2109., 2244.,
      1992., 2136., 2280., 2424., 2145., 2298., 2451., 2604., 1701., 1806.,
      1911., 2016., 1310., 1376., 1442., 1508., 2222., 2324., 2426., 2528.,
      2360., 2468., 2576., 2684., 2498., 2612., 2726., 2840., 2636., 2756.,
      2876., 2996., 1974., 2056., 2138., 2220.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   7.,   10.,  13.,  16.,  22.,  28.,  34.,  40.,
      37.,  46.,  55.,  64.,  47.,  54.,  61.,  68.,  36.,  40.,  44.,  48.,
      18.,  24.,  30.,  36.,  74.,  88.,  102., 116., 176., 200., 224., 248.,
      242., 272., 302., 332., 234., 256., 278., 300., 156., 168., 180., 192.,
      90.,  96.,  102., 108., 242., 256., 270., 284., 464., 488., 512., 536.,
      602., 632., 662., 692., 498., 520., 542., 564., 300., 312., 324., 336.,
      125., 130., 135., 140., 295., 306., 317., 328., 514., 532., 550., 568.,
      601., 622., 643., 664., 463., 478., 493., 508., 264., 272., 280., 288.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      584.,   720.,   856.,   992.,   1462.,  1690.,  1918.,  2146.,  1978.,
      2254.,  2530.,  2806.,  2494.,  2818.,  3142.,  3466.,  3010.,  3382.,
      3754.,  4126.,  2760.,  3024.,  3288.,  3552.,  2784.,  3132.,  3480.,
      3828.,  5703.,  6261.,  6819.,  7377.,  6909.,  7539.,  8169.,  8799.,
      8115.,  8817.,  9519.,  10221., 9321.,  10095., 10869., 11643., 7776.,
      8316.,  8856.,  9396.,  7032.,  7668.,  8304.,  8940.,  12939., 13929.,
      14919., 15909., 14145., 15207., 16269., 17331., 15351., 16485., 17619.,
      18753., 16557., 17763., 18969., 20175., 13176., 14004., 14832., 15660.,
      10184., 10704., 11224., 11744., 17302., 18106., 18910., 19714., 18394.,
      19246., 20098., 20950., 19486., 20386., 21286., 22186., 20578., 21526.,
      22474., 23422., 15432., 16080., 16728., 17376.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    11.,   17.,   23.,   40.,   60.,   80.,   100.,  137.,  179.,
      221.,  263.,  251.,  317.,  383.,  449.,  336.,  388.,  440.,  492.,
      263.,  293.,  323.,  353.,  106.,  150.,  194.,  238.,  496.,  600.,
      704.,  808.,  1234., 1414., 1594., 1774., 1750., 1978., 2206., 2434.,
      1728., 1896., 2064., 2232., 1166., 1258., 1350., 1442., 634.,  678.,
      722.,  766.,  1744., 1848., 1952., 2056., 3394., 3574., 3754., 3934.,
      4486., 4714., 4942., 5170., 3744., 3912., 4080., 4248., 2270., 2362.,
      2454., 2546., 941.,  979.,  1017., 1055., 2232., 2316., 2400., 2484.,
      3905., 4043., 4181., 4319., 4595., 4757., 4919., 5081., 3552., 3668.,
      3784., 3900., 2031., 2093., 2155., 2217.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4264.,   5320.,   6376.,   7432.,   10964.,  12740.,  14516.,  16292.,
      15044.,  17204.,  19364.,  21524.,  19124.,  21668.,  24212.,  26756.,
      23204.,  26132.,  29060.,  31988.,  21416.,  23496.,  25576.,  27656.,
      21228.,  23964.,  26700.,  29436.,  43878.,  48270.,  52662.,  57054.,
      53454.,  58422.,  63390.,  68358.,  63030.,  68574.,  74118.,  79662.,
      72606.,  78726.,  84846.,  90966.,  60780.,  65052.,  69324.,  73596.,
      54924.,  59964.,  65004.,  70044.,  101334., 109182., 117030., 124878.,
      110910., 119334., 127758., 136182., 120486., 129486., 138486., 147486.,
      130062., 139638., 149214., 158790., 103692., 110268., 116844., 123420.,
      80296.,  84424.,  88552.,  92680.,  136532., 142916., 149300., 155684.,
      145220., 151988., 158756., 165524., 153908., 161060., 168212., 175364.,
      162596., 170132., 177668., 185204., 122024., 127176., 132328., 137480.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    70.,    110.,   150.,   260.,   404.,   548.,   692.,   946.,
      1258.,  1570.,  1882.,  1834.,  2338.,  2842.,  3346.,  2532.,  2932.,
      3332.,  3732.,  2006.,  2238.,  2470.,  2702.,  700.,   1036.,  1372.,
      1708.,  3592.,  4392.,  5192.,  5992.,  9188.,  10580., 11972., 13364.,
      13268., 15044., 16820., 18596., 13256., 14568., 15880., 17192., 9004.,
      9724.,  10444., 11164., 4732.,  5068.,  5404.,  5740.,  13192., 13992.,
      14792., 15592., 25892., 27284., 28676., 30068., 34580., 36356., 38132.,
      39908., 29000., 30312., 31624., 32936., 17644., 18364., 19084., 19804.,
      7294.,  7590.,  7886.,  8182.,  17348., 18004., 18660., 19316., 30418.,
      31498., 32578., 33658., 35914., 37186., 38458., 39730., 27812., 28724.,
      29636., 30548., 15926., 16414., 16902., 17390.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29.,  62.,  83.,  75.,  99.,  192., 237., 198., 207., 372.,
      417., 330., 315., 552., 597., 462., 359., 602., 641., 477.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,   4.,  7.,  6.,  7.,  23., 33.,
                                         24.,  24., 69., 90., 60., 41., 101.,
                                         119., 72., 35., 82., 93., 54.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      184.,  412.,  568.,  528.,  678.,  1347., 1689., 1434., 1494., 2715.,
      3057., 2442., 2310., 4083., 4425., 3450., 2704., 4552., 4852., 3624.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   22.,  42.,  39.,  40.,  144., 216., 164., 153., 462.,
      618., 423., 292., 728., 864., 528., 257., 606., 690., 403.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1288.,  2972.,  4172.,  3944.,  4980.,  10038., 12702.,
      10884., 11316., 20694., 23358., 18756., 17652., 31350.,
      34014., 26628., 20968., 35372., 37724., 28232.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   140.,  284.,  278.,  260.,  1000., 1544., 1204., 1074., 3348.,
      4548., 3162., 2196., 5512., 6568., 4036., 1966., 4652., 5308., 3110.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      44.,  58.,  100., 124., 136.,  166.,  128.,  150.,  165.,  198.,
      330., 384., 411., 474., 351.,  396.,  357.,  414.,  654.,  744.,
      735., 834., 591., 660., 549.,  630.,  978.,  1104., 1059., 1194.,
      831., 924., 656., 718., 1108., 1204., 1180., 1282., 884.,  954.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   5.,   8.,   11.,  14.,  10.,  12.,  10.,  14.,
      36.,  46.,  56.,  66.,  42.,  48.,  39.,  48.,  117., 138.,
      159., 180., 108., 120., 74.,  82.,  184., 202., 220., 238.,
      134., 144., 65.,  70.,  153., 164., 175., 186., 102., 108.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      288.,  392.,  686.,  866.,  962.,  1190., 928.,  1096., 1164., 1416.,
      2379., 2793., 3009., 3495., 2604., 2952., 2652., 3096., 4899., 5601.,
      5529., 6303., 4476., 5016., 4140., 4776., 7419., 8409., 8049., 9111.,
      6348., 7080., 5040., 5528., 8534., 9290., 9098., 9902., 6832., 7384.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    11.,   28.,  48.,  68.,   88.,   67.,   81.,   58.,   86.,
      232.,  304.,  376., 448., 294.,  338.,  255.,  321.,  804.,  960.,
      1116., 1272., 777., 867., 538.,  598.,  1352., 1488., 1624., 1760.,
      998.,  1074., 485., 523., 1148., 1232., 1316., 1400., 771.,  817.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2056.,  2856.,  5044.,  6436.,  7204.,  8980.,  7048.,  8360.,
      8700.,  10668., 18006., 21246., 22974., 26790., 20028., 22764.,
      20412., 23916., 37878., 43422., 42846., 48966., 34812., 39084.,
      32124., 37164., 57750., 65598., 62718., 71142., 49596., 55404.,
      39496., 43368., 66964., 72964., 71428., 77812., 53704., 58088.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   180.,  324.,  468.,  612.,  486.,   590.,   380.,   588.,
      1640., 2184., 2728., 3272., 2188., 2524., 1818.,  2322.,  5916.,  7116.,
      8316., 9516., 5874., 6570., 4092., 4556., 10344., 11400., 12456., 13512.,
      7692., 8284., 3742., 4038., 8884., 9540., 10196., 10852., 5990.,  6350.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      74.,   88.,   102.,  116.,  176.,  200.,  224.,  248.,  242.,  272.,
      302.,  332.,  234.,  256.,  278.,  300.,  297.,  330.,  363.,  396.,
      606.,  660.,  714.,  768.,  759.,  822.,  885.,  948.,  657.,  702.,
      747.,  792.,  657.,  714.,  771.,  828.,  1218., 1308., 1398., 1488.,
      1371., 1470., 1569., 1668., 1113., 1182., 1251., 1320., 1017., 1098.,
      1179., 1260., 1830., 1956., 2082., 2208., 1983., 2118., 2253., 2388.,
      1569., 1662., 1755., 1848., 1250., 1312., 1374., 1436., 2120., 2216.,
      2312., 2408., 2258., 2360., 2462., 2564., 1698., 1768., 1838., 1908.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   7.,   10.,  13.,  16.,  19.,  22.,  25.,  28.,
      18.,  20.,  22.,  24.,  16.,  20.,  24.,  28.,  62.,  72.,  82.,  92.,
      102., 112., 122., 132., 78.,  84.,  90.,  96.,  69.,  78.,  87.,  96.,
      213., 234., 255., 276., 297., 318., 339., 360., 204., 216., 228., 240.,
      140., 148., 156., 164., 350., 368., 386., 404., 422., 440., 458., 476.,
      258., 268., 278., 288., 125., 130., 135., 140., 295., 306., 317., 328.,
      339., 350., 361., 372., 198., 204., 210., 216.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      496.,   600.,   704.,   808.,   1234.,  1414.,  1594.,  1774.,  1750.,
      1978.,  2206.,  2434.,  1728.,  1896.,  2064.,  2232.,  2136.,  2388.,
      2640.,  2892.,  4443.,  4857.,  5271.,  5685.,  5649.,  6135.,  6621.,
      7107.,  4944.,  5292.,  5640.,  5988.,  4968.,  5412.,  5856.,  6300.,
      9267.,  9969.,  10671., 11373., 10473., 11247., 12021., 12795., 8544.,
      9084.,  9624.,  10164., 7800.,  8436.,  9072.,  9708.,  14091., 15081.,
      16071., 17061., 15297., 16359., 17421., 18483., 12144., 12876., 13608.,
      14340., 9712.,  10200., 10688., 11176., 16498., 17254., 18010., 18766.,
      17590., 18394., 19198., 20002., 13248., 13800., 14352., 14904.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    11.,   17.,   23.,   40.,   60.,   80.,   100.,  120.,  140.,
      160.,  180.,  123.,  137.,  151.,  165.,  94.,   122.,  150.,  178.,
      408.,  480.,  552.,  624.,  696.,  768.,  840.,  912.,  554.,  598.,
      642.,  686.,  459.,  525.,  591.,  657.,  1488., 1644., 1800., 1956.,
      2112., 2268., 2424., 2580., 1485., 1575., 1665., 1755., 1030., 1090.,
      1150., 1210., 2600., 2736., 2872., 3008., 3144., 3280., 3416., 3552.,
      1938., 2014., 2090., 2166., 941.,  979.,  1017., 1055., 2232., 2316.,
      2400., 2484., 2568., 2652., 2736., 2820., 1507., 1553., 1599., 1645.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3592.,   4392.,   5192.,   5992.,   9188.,   10580.,  11972.,  13364.,
      13268.,  15044.,  16820.,  18596.,  13256.,  14568.,  15880.,  17192.,
      16140.,  18108.,  20076.,  22044.,  33942.,  37182.,  40422.,  43662.,
      43518.,  47334.,  51150.,  54966.,  38316.,  41052.,  43788.,  46524.,
      38604.,  42108.,  45612.,  49116.,  72246.,  77790.,  83334.,  88878.,
      81822.,  87942.,  94062.,  100182., 66924.,  71196.,  75468.,  79740.,
      61068.,  66108.,  71148.,  76188.,  110550., 118398., 126246., 134094.,
      120126., 128550., 136974., 145398., 95532.,  101340., 107148., 112956.,
      76552.,  80424.,  84296.,  88168.,  130148., 136148., 142148., 148148.,
      138836., 145220., 151604., 157988., 104648., 109032., 113416., 117800.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    70.,    110.,   150.,   260.,   404.,   548.,   692.,   836.,
      980.,   1124.,  1268.,  902.,   1006.,  1110.,  1214.,  620.,   828.,
      1036.,  1244.,  2920.,  3464.,  4008.,  4552.,  5096.,  5640.,  6184.,
      6728.,  4156.,  4492.,  4828.,  5164.,  3306.,  3810.,  4314.,  4818.,
      11052., 12252., 13452., 14652., 15852., 17052., 18252., 19452., 11298.,
      11994., 12690., 13386., 7884.,  8348.,  8812.,  9276.,  20008., 21064.,
      22120., 23176., 24232., 25288., 26344., 27400., 15004., 15596., 16188.,
      16780., 7294.,  7590.,  7886.,  8182.,  17348., 18004., 18660., 19316.,
      19972., 20628., 21284., 21940., 11750., 12110., 12470., 12830.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      32.,  68.,  89.,  110., 96.,  114., 219., 264., 309.,
      252., 249., 444., 489., 534., 417., 384., 669., 714.,
      759., 582., 440., 734., 773., 812., 600.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   4.,  10., 12.,  9.,   8.,   26.,  56., 54.,  36.,  30.,  84., 165.,
      144., 90., 56., 134., 236., 186., 108., 49., 112., 190., 144., 81.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      204.,  454.,  610.,  766.,  684.,  786.,  1545., 1887., 2229.,
      1842., 1806., 3255., 3597., 3939., 3102., 2826., 4965., 5307.,
      5649., 4362., 3324., 5566., 5866., 6166., 4572.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    22.,  59.,  78.,   61.,   46.,   164., 370., 372.,
      254.,  195., 570., 1149., 1026., 651.,  406., 980., 1738.,
      1380., 806., 365., 838.,  1427., 1086., 613.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1432.,  3284.,  4484.,  5684.,  5144.,  5796.,  11550., 14214., 16878.,
      14052., 13716., 24870., 27534., 30198., 23892., 21636., 38190., 40854.,
      43518., 33732., 25816., 43316., 45668., 48020., 35672.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    140.,  394.,  556.,  446.,   300.,  1144., 2660., 2744.,
      1900.,  1386., 4164., 8526., 7716.,  4938., 3084., 7480., 13316.,
      10616., 6220., 2814., 6476., 11050., 8428., 4766.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      48.,  64.,  109.,  136.,  145.,  178.,  181.,  220.,  164.,  192.,
      189., 228., 375.,  438.,  456.,  528.,  537.,  618.,  447.,  504.,
      429., 498., 780.,  888.,  861.,  978.,  942.,  1068., 747.,  834.,
      669., 768., 1185., 1338., 1266., 1428., 1347., 1518., 1047., 1164.,
      804., 880., 1351., 1468., 1423., 1546., 1495., 1624., 1112., 1200.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   5.,   8.,   14.,  20.,  19.,  24.,  15.,  18.,
      11.,  16.,  40.,  52.,  91.,  112., 92.,  108., 63.,  72.,
      48.,  60.,  141., 168., 285., 330., 255., 288., 162., 180.,
      101., 112., 244., 268., 433., 472., 344., 372., 201., 216.,
      91.,  98.,  209., 224., 356., 380., 271., 288., 153., 162.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      316.,   436.,   752.,   956.,  1028., 1280., 1304.,  1604.,  1204.,
      1420.,  1344.,  1644.,  2721., 3207., 3351., 3909.,  3981.,  4611.,
      3348.,  3792.,  3204.,  3744., 5871., 6717., 6501.,  7419.,  7131.,
      8121.,  5688.,  6372.,  5064., 5844., 9021., 10227., 9651.,  10929.,
      10281., 11631., 8028.,  8952., 6196., 6796., 10436., 11360., 11000.,
      11972., 11564., 12584., 8620., 9316.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   11.,  28.,   48.,   85.,   127.,  128.,  164.,  105.,  127.,
      64.,  100., 260.,  348.,  620.,  776.,  652.,  772.,  456.,  524.,
      321., 411., 984.,  1188., 2037., 2379., 1860., 2112., 1197., 1335.,
      748., 832., 1820., 2004., 3248., 3548., 2596., 2812., 1524., 1640.,
      689., 743., 1588., 1704., 2713., 2899., 2072., 2204., 1173., 1243.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2264.,  3192.,  5548.,  7132.,  7708.,  9676.,  9868.,  12220., 9208.,
      10904., 10092., 12444., 20670., 24486., 25638., 30030., 30606., 35574.,
      25884., 29388., 24732., 29004., 45510., 52206., 50478., 57750., 55446.,
      63294., 44364., 49788., 39372., 45564., 70350., 79926., 75318., 85470.,
      80286., 91014., 62844., 70188., 48632., 53400., 82012., 89356., 86476.,
      94204., 90940., 99052., 67864., 73400.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    70.,    180.,   324.,   578.,  890.,   932.,   1204.,  782.,
      950.,   420.,   692.,   1848.,  2520., 4540.,  5740.,  4888.,  5816.,
      3460.,  3988.,  2322.,  3018.,  7308., 8892.,  15342., 18006., 14172.,
      16140., 9186.,  10266., 5748.,  6404., 14040., 15480., 25132., 27484.,
      20152., 21848., 11860., 12772., 5358., 5782.,  12372., 13284., 21170.,
      22634., 16196., 17236., 9182.,  9734.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      80.,   96.,   112.,  128.,  191.,  218.,  245.,  272.,  257.,  290.,
      323.,  356.,  323.,  362.,  401.,  440.,  300.,  328.,  356.,  384.,
      339.,  378.,  417.,  456.,  687.,  750.,  813.,  876.,  840.,  912.,
      984.,  1056., 993.,  1074., 1155., 1236., 837.,  894.,  951.,  1008.,
      789.,  858.,  927.,  996.,  1452., 1560., 1668., 1776., 1605., 1722.,
      1839., 1956., 1758., 1884., 2010., 2136., 1407., 1494., 1581., 1668.,
      1239., 1338., 1437., 1536., 2217., 2370., 2523., 2676., 2370., 2532.,
      2694., 2856., 2523., 2694., 2865., 3036., 1977., 2094., 2211., 2328.,
      1532., 1608., 1684., 1760., 2585., 2702., 2819., 2936., 2723., 2846.,
      2969., 3092., 2861., 2990., 3119., 3248., 2136., 2224., 2312., 2400.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   7.,   10.,  13.,  16.,  22.,  28.,  34.,  40.,
      33.,  38.,  43.,  48.,  27.,  30.,  33.,  36.,  17.,  22.,  27.,  32.,
      68.,  80.,  92.,  104., 161., 182., 203., 224., 168., 184., 200., 216.,
      117., 126., 135., 144., 84.,  96.,  108., 120., 255., 282., 309., 336.,
      525., 570., 615., 660., 477., 510., 543., 576., 306., 324., 342., 360.,
      191., 202., 213., 224., 464., 488., 512., 536., 827., 866., 905., 944.,
      660., 688., 716., 744., 387., 402., 417., 432., 175., 182., 189., 196.,
      403., 418., 433., 448., 688., 712., 736., 760., 525., 542., 559., 576.,
      297., 306., 315., 324.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      540.,   660.,   780.,   900.,   1348.,  1552.,  1756.,  1960.,  1864.,
      2116.,  2368.,  2620.,  2380.,  2680.,  2980.,  3280.,  2244.,  2460.,
      2676.,  2892.,  2460.,  2760.,  3060.,  3360.,  5073.,  5559.,  6045.,
      6531.,  6279.,  6837.,  7395.,  7953.,  7485.,  8115.,  8745.,  9375.,
      6360.,  6804.,  7248.,  7692.,  6000.,  6540.,  7080.,  7620.,  11103.,
      11949., 12795., 13641., 12309., 13227., 14145., 15063., 13515., 14505.,
      15495., 16485., 10860., 11544., 12228., 12912., 9540.,  10320., 11100.,
      11880., 17133., 18339., 19545., 20751., 18339., 19617., 20895., 22173.,
      19545., 20895., 22245., 23595., 15360., 16284., 17208., 18132., 11940.,
      12540., 13140., 13740., 20176., 21100., 22024., 22948., 21268., 22240.,
      23212., 24184., 22360., 23380., 24400., 25420., 16716., 17412., 18108.,
      18804.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    11.,   17.,   23.,   40.,   60.,   80.,   100.,  137.,  179.,
      221.,  263.,  228.,  264.,  300.,  336.,  193.,  215.,  237.,  259.,
      100.,  136.,  172.,  208.,  452.,  540.,  628.,  716.,  1120., 1276.,
      1432., 1588., 1212., 1332., 1452., 1572., 860.,  928.,  996.,  1064.,
      573.,  663.,  753.,  843.,  1812., 2016., 2220., 2424., 3813., 4155.,
      4497., 4839., 3528., 3780., 4032., 4284., 2289., 2427., 2565., 2703.,
      1432., 1516., 1600., 1684., 3500., 3684., 3868., 4052., 6268., 6568.,
      6868., 7168., 5028., 5244., 5460., 5676., 2960., 3076., 3192., 3308.,
      1337., 1391., 1445., 1499., 3088., 3204., 3320., 3436., 5285., 5471.,
      5657., 5843., 4044., 4176., 4308., 4440., 2293., 2363., 2433., 2503.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3928.,   4856.,   5784.,   6712.,   10076.,  11660.,  13244.,  14828.,
      14156.,  16124.,  18092.,  20060.,  18236.,  20588.,  22940.,  25292.,
      17336.,  19032.,  20728.,  22424.,  18684.,  21036.,  23388.,  25740.,
      38910.,  42726.,  46542.,  50358.,  48486.,  52878.,  57270.,  61662.,
      58062.,  63030.,  67998.,  72966.,  49548.,  53052.,  56556.,  60060.,
      46764.,  51036.,  55308.,  59580.,  86790.,  93486.,  100182., 106878.,
      96366.,  103638., 110910., 118182., 105942., 113790., 121638., 129486.,
      85308.,  90732.,  96156.,  101580., 74844.,  81036.,  87228.,  93420.,
      134670., 144246., 153822., 163398., 144246., 154398., 164550., 174702.,
      153822., 164550., 175278., 186006., 121068., 128412., 135756., 143100.,
      94264.,  99032.,  103800., 108568., 159404., 166748., 174092., 181436.,
      168092., 175820., 183548., 191276., 176780., 184892., 193004., 201116.,
      132248., 137784., 143320., 148856.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    70.,    110.,   150.,   260.,   404.,   548.,   692.,   946.,
      1258.,  1570.,  1882.,  1684.,  1956.,  2228.,  2500.,  1454.,  1622.,
      1790.,  1958.,  660.,   932.,   1204.,  1476.,  3256.,  3928.,  4600.,
      5272.,  8300.,  9500.,  10700., 11900., 9176.,  10104., 11032., 11960.,
      6580.,  7108.,  7636.,  8164.,  4194.,  4890.,  5586.,  6282.,  13596.,
      15180., 16764., 18348., 28974., 31638., 34302., 36966., 27084., 29052.,
      31020., 32988., 17682., 18762., 19842., 20922., 11076., 11732., 12388.,
      13044., 27160., 28600., 30040., 31480., 48764., 51116., 53468., 55820.,
      39224., 40920., 42616., 44312., 23140., 24052., 24964., 25876., 10446.,
      10870., 11294., 11718., 24164., 25076., 25988., 26900., 41410., 42874.,
      44338., 45802., 31732., 32772., 33812., 34852., 18014., 18566., 19118.,
      19670.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      35.,  74.,  95.,  116., 137., 117., 129., 246., 291., 336.,
      381., 306., 291., 516., 561., 606., 651., 504., 453., 786.,
      831., 876., 921., 702., 521., 866., 905., 944., 983., 723.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   4.,   10.,  16.,  17.,  12.,  9.,   29.,  62.,  83.,
      75.,  48.,  36.,  99.,  192., 237., 198., 120., 71.,  167.,
      290., 329., 253., 144., 63.,  142., 238., 262., 195., 108.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      224.,  496.,  652.,  808.,  964.,  840.,  894.,  1743., 2085., 2427.,
      2769., 2250., 2118., 3795., 4137., 4479., 4821., 3762., 3342., 5847.,
      6189., 6531., 6873., 5274., 3944., 6580., 6880., 7180., 7480., 5520.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    22.,   59.,   101.,  114.,  83.,   52.,   184.,  412.,  568.,
      528.,  344.,  237.,  678.,  1347., 1689., 1434., 879.,  520.,  1232.,
      2152., 2452., 1896., 1084., 473.,  1070., 1799., 1985., 1482., 823.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1576.,  3596.,  4796.,  5996.,  7196.,  6344.,  6612.,  13062.,
      15726., 18390., 21054., 17220., 16116., 29046., 31710., 34374.,
      37038., 29028., 25620., 45030., 47694., 50358., 53022., 40836.,
      30664., 51260., 53612., 55964., 58316., 43112.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    140.,  394.,   706.,   828.,   614.,   340.,   1288.,
      2972.,  4172., 3944.,  2596.,  1698.,  4980.,  10038., 12702.,
      10884., 6714., 3972.,  9448.,  16556., 18908., 14664., 8404.,
      3662.,  8300., 13978., 15442., 11548., 6422.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      52.,   70.,   118.,  148.,  154.,  190.,  190.,  232.,  226.,  274.,
      200.,  234.,  213.,  258.,  420.,  492.,  501.,  582.,  582.,  672.,
      663.,  762.,  543.,  612.,  501.,  582.,  906.,  1032., 987.,  1122.,
      1068., 1212., 1149., 1302., 903.,  1008., 789.,  906.,  1392., 1572.,
      1473., 1662., 1554., 1752., 1635., 1842., 1263., 1404., 952.,  1042.,
      1594., 1732., 1666., 1810., 1738., 1888., 1810., 1966., 1340., 1446.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   5.,   8.,   14.,  20.,  23.,  32.,  27.,  34.,  20.,  24.,
      12.,  18.,  44.,  58.,  100., 124., 136., 166., 128., 150., 84.,  96.,
      57.,  72.,  165., 198., 330., 384., 411., 474., 351., 396., 216., 240.,
      128., 142., 304., 334., 532., 580., 604., 658., 468., 506., 268., 288.,
      117., 126., 265., 284., 446., 476., 491., 524., 367., 390., 204., 216.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      344.,   480.,   818.,   1046.,  1094.,  1370.,  1370.,  1694.,  1646.,
      2018.,  1480.,  1744.,  1524.,  1872.,  3063.,  3621.,  3693.,  4323.,
      4323.,  5025.,  4953.,  5727.,  4092.,  4632.,  3756.,  4392.,  6843.,
      7833.,  7473.,  8535.,  8103.,  9237.,  8733.,  9939.,  6900.,  7728.,
      5988.,  6912.,  10623., 12045., 11253., 12747., 11883., 13449., 12513.,
      14151., 9708.,  10824., 7352.,  8064.,  12338., 13430., 12902., 14042.,
      13466., 14654., 14030., 15266., 10408., 11248.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    11.,   28.,   48.,   85.,   127.,  151.,  217.,  188.,  240.,
      143.,  173.,  70.,   114.,  288.,  392.,  686.,  866.,  962.,  1190.,
      928.,  1096., 618.,  710.,  387.,  501.,  1164., 1416., 2379., 2793.,
      3009., 3495., 2604., 2952., 1617., 1803., 958.,  1066., 2288., 2520.,
      4022., 4394., 4586., 5006., 3568., 3864., 2050., 2206., 893.,  963.,
      2028., 2176., 3421., 3655., 3775., 4033., 2828., 3008., 1575., 1669.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2472.,   3528.,   6052.,  7828.,   8212.,   10372.,  10372.,  12916.,
      12532.,  15460.,  11368., 13448.,  11484.,  14220.,  23334.,  27726.,
      28302.,  33270.,  33270., 38814.,  38238.,  44358.,  31740.,  36012.,
      29052.,  34092.,  53142., 60990.,  58110.,  66534.,  63078.,  72078.,
      68046.,  77622.,  53916., 60492.,  46620.,  53964.,  82950.,  94254.,
      87918.,  99798.,  92886., 105342., 97854.,  110886., 76092.,  84972.,
      57768.,  63432.,  97060., 105748., 101524., 110596., 105988., 115444.,
      110452., 120292., 82024., 88712.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    70.,    180.,   324.,   578.,   890.,   1082.,  1586.,  1396.,
      1796.,  1078.,  1310.,  460.,   796.,   2056.,  2856.,  5044.,  6436.,
      7204.,  8980.,  7048.,  8360.,  4732.,  5452.,  2826.,  3714.,  8700.,
      10668., 18006., 21246., 22974., 26790., 20028., 22764., 12498., 13962.,
      7404.,  8252.,  17736., 19560., 31252., 34180., 35716., 39028., 27848.,
      30184., 16028., 17260., 6974.,  7526.,  15860., 17028., 26786., 28634.,
      29594., 31634., 22196., 23620., 12374., 13118.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      86.,   104.,  122.,  140.,  206.,  236.,  266.,  296.,  272.,  308.,
      344.,  380.,  338.,  380.,  422.,  464.,  404.,  452.,  500.,  548.,
      366.,  400.,  434.,  468.,  381.,  426.,  471.,  516.,  768.,  840.,
      912.,  984.,  921.,  1002., 1083., 1164., 1074., 1164., 1254., 1344.,
      1227., 1326., 1425., 1524., 1017., 1086., 1155., 1224., 921.,  1002.,
      1083., 1164., 1686., 1812., 1938., 2064., 1839., 1974., 2109., 2244.,
      1992., 2136., 2280., 2424., 2145., 2298., 2451., 2604., 1701., 1806.,
      1911., 2016., 1461., 1578., 1695., 1812., 2604., 2784., 2964., 3144.,
      2757., 2946., 3135., 3324., 2910., 3108., 3306., 3504., 3063., 3270.,
      3477., 3684., 2385., 2526., 2667., 2808., 1814., 1904., 1994., 2084.,
      3050., 3188., 3326., 3464., 3188., 3332., 3476., 3620., 3326., 3476.,
      3626., 3776., 3464., 3620., 3776., 3932., 2574., 2680., 2786., 2892.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    2.,    3.,    4.,    7.,    10.,   13.,   16.,   22.,  28.,
      34.,   40.,   37.,   46.,   55.,   64.,   47.,   54.,   61.,  68.,
      36.,   40.,   44.,   48.,   18.,   24.,   30.,   36.,   74.,  88.,
      102.,  116.,  176.,  200.,  224.,  248.,  242.,  272.,  302., 332.,
      234.,  256.,  278.,  300.,  156.,  168.,  180.,  192.,  99.,  114.,
      129.,  144.,  297.,  330.,  363.,  396.,  606.,  660.,  714., 768.,
      759.,  822.,  885.,  948.,  657.,  702.,  747.,  792.,  408., 432.,
      456.,  480.,  242.,  256.,  270.,  284.,  578.,  608.,  638., 668.,
      1016., 1064., 1112., 1160., 1154., 1208., 1262., 1316., 898., 936.,
      974.,  1012., 516.,  536.,  556.,  576.,  225.,  234.,  243., 252.,
      511.,  530.,  549.,  568.,  862.,  892.,  922.,  952.,  949., 982.,
      1015., 1048., 711.,  734.,  757.,  780.,  396.,  408.,  420., 432.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      584.,   720.,   856.,   992.,   1462.,  1690.,  1918.,  2146.,  1978.,
      2254.,  2530.,  2806.,  2494.,  2818.,  3142.,  3466.,  3010.,  3382.,
      3754.,  4126.,  2760.,  3024.,  3288.,  3552.,  2784.,  3132.,  3480.,
      3828.,  5703.,  6261.,  6819.,  7377.,  6909.,  7539.,  8169.,  8799.,
      8115.,  8817.,  9519.,  10221., 9321.,  10095., 10869., 11643., 7776.,
      8316.,  8856.,  9396.,  7032.,  7668.,  8304.,  8940.,  12939., 13929.,
      14919., 15909., 14145., 15207., 16269., 17331., 15351., 16485., 17619.,
      18753., 16557., 17763., 18969., 20175., 13176., 14004., 14832., 15660.,
      11280., 12204., 13128., 14052., 20175., 21597., 23019., 24441., 21381.,
      22875., 24369., 25863., 22587., 24153., 25719., 27285., 23793., 25431.,
      27069., 28707., 18576., 19692., 20808., 21924., 14168., 14880., 15592.,
      16304., 23854., 24946., 26038., 27130., 24946., 26086., 27226., 28366.,
      26038., 27226., 28414., 29602., 27130., 28366., 29602., 30838., 20184.,
      21024., 21864., 22704.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    11.,   17.,   23.,   40.,   60.,   80.,   100.,   137.,  179.,
      221.,  263.,  251.,  317.,  383.,  449.,  336.,  388.,   440.,  492.,
      263.,  293.,  323.,  353.,  106.,  150.,  194.,  238.,   496.,  600.,
      704.,  808.,  1234., 1414., 1594., 1774., 1750., 1978.,  2206., 2434.,
      1728., 1896., 2064., 2232., 1166., 1258., 1350., 1442.,  687.,  801.,
      915.,  1029., 2136., 2388., 2640., 2892., 4443., 4857.,  5271., 5685.,
      5649., 6135., 6621., 7107., 4944., 5292., 5640., 5988.,  3093., 3279.,
      3465., 3651., 1834., 1942., 2050., 2158., 4400., 4632.,  4864., 5096.,
      7762., 8134., 8506., 8878., 8854., 9274., 9694., 10114., 6912., 7208.,
      7504., 7800., 3982., 4138., 4294., 4450., 1733., 1803.,  1873., 1943.,
      3944., 4092., 4240., 4388., 6665., 6899., 7133., 7367.,  7355., 7613.,
      7871., 8129., 5520., 5700., 5880., 6060., 3079., 3173.,  3267., 3361.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4264.,   5320.,   6376.,   7432.,   10964.,  12740.,  14516.,  16292.,
      15044.,  17204.,  19364.,  21524.,  19124.,  21668.,  24212.,  26756.,
      23204.,  26132.,  29060.,  31988.,  21416.,  23496.,  25576.,  27656.,
      21228.,  23964.,  26700.,  29436.,  43878.,  48270.,  52662.,  57054.,
      53454.,  58422.,  63390.,  68358.,  63030.,  68574.,  74118.,  79662.,
      72606.,  78726.,  84846.,  90966.,  60780.,  65052.,  69324.,  73596.,
      54924.,  59964.,  65004.,  70044.,  101334., 109182., 117030., 124878.,
      110910., 119334., 127758., 136182., 120486., 129486., 138486., 147486.,
      130062., 139638., 149214., 158790., 103692., 110268., 116844., 123420.,
      88620.,  95964.,  103308., 110652., 158790., 170094., 181398., 192702.,
      168366., 180246., 192126., 204006., 177942., 190398., 202854., 215310.,
      187518., 200550., 213582., 226614., 146604., 155484., 164364., 173244.,
      111976., 117640., 123304., 128968., 188660., 197348., 206036., 214724.,
      197348., 206420., 215492., 224564., 206036., 215492., 224948., 234404.,
      214724., 224564., 234404., 244244., 159848., 166536., 173224., 179912.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    70.,    110.,   150.,   260.,   404.,   548.,   692.,   946.,
      1258.,  1570.,  1882.,  1834.,  2338.,  2842.,  3346.,  2532.,  2932.,
      3332.,  3732.,  2006.,  2238.,  2470.,  2702.,  700.,   1036.,  1372.,
      1708.,  3592.,  4392.,  5192.,  5992.,  9188.,  10580., 11972., 13364.,
      13268., 15044., 16820., 18596., 13256., 14568., 15880., 17192., 9004.,
      9724.,  10444., 11164., 5082.,  5970.,  6858.,  7746.,  16140., 18108.,
      20076., 22044., 33942., 37182., 40422., 43662., 43518., 47334., 51150.,
      54966., 38316., 41052., 43788., 46524., 24066., 25530., 26994., 28458.,
      14268., 15116., 15964., 16812., 34312., 36136., 37960., 39784., 60644.,
      63572., 66500., 69428., 69332., 72644., 75956., 79268., 54216., 56552.,
      58888., 61224., 31276., 32508., 33740., 34972., 13598., 14150., 14702.,
      15254., 30980., 32148., 33316., 34484., 52402., 54250., 56098., 57946.,
      57898., 59938., 61978., 64018., 43492., 44916., 46340., 47764., 24278.,
      25022., 25766., 26510.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29.,  62.,  83.,  75.,  99.,  192., 237., 198., 207., 372., 417., 330.,
      315., 552., 597., 462., 423., 732., 777., 594., 455., 758., 797., 589.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,   7.,   6.,  7.,  23.,  33.,  24.,  24., 69.,  90.,  60.,
      48., 123., 156., 96., 63., 149., 175., 102., 49., 112., 127., 72.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      184.,  412.,  568.,  528.,  678.,  1347., 1689., 1434.,
      1494., 2715., 3057., 2442., 2310., 4083., 4425., 3450.,
      3126., 5451., 5793., 4458., 3440., 5752., 6052., 4488.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,    22.,  42.,   39.,  40.,  144.,
                                         216.,  164., 153.,  462., 618., 423.,
                                         333.,  870., 1122., 699., 460., 1096.,
                                         1296., 760., 365.,  838., 954., 543.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1288.,  2972.,  4172.,  3944.,  4980.,  10038., 12702., 10884.,
      11316., 20694., 23358., 18756., 17652., 31350., 34014., 26628.,
      23988., 42006., 44670., 34500., 26728., 44780., 47132., 35016.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   140.,  284.,  278.,  260.,  1000., 1544., 1204.,
      1074., 3348., 4548., 3162., 2466., 6516., 8484., 5322.,
      3508., 8392., 9960., 5860., 2814., 6476., 7388., 4214.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      44.,  58.,  100.,  124.,  136.,  166.,  128.,  150.,  165.,  198.,
      330., 384., 411.,  474.,  351.,  396.,  357.,  414.,  654.,  744.,
      735., 834., 591.,  660.,  549.,  630.,  978.,  1104., 1059., 1194.,
      831., 924., 741.,  846.,  1302., 1464., 1383., 1554., 1071., 1188.,
      832., 910., 1396., 1516., 1468., 1594., 1092., 1178.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   5.,   8.,   11.,  14.,  10.,  12.,  10.,  14.,  36.,  46.,
      56.,  66.,  42.,  48.,  39.,  48.,  117., 138., 159., 180., 108., 120.,
      81.,  96.,  213., 246., 279., 312., 174., 192., 114., 126., 272., 298.,
      324., 350., 190., 204., 91.,  98.,  209., 224., 239., 254., 136., 144.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      288.,  392.,  686.,   866.,   962.,   1190.,  928.,  1096.,
      1164., 1416., 2379.,  2793.,  3009.,  3495.,  2604., 2952.,
      2652., 3096., 4899.,  5601.,  5529.,  6303.,  4476., 5016.,
      4140., 4776., 7419.,  8409.,  8049.,  9111.,  6348., 7080.,
      5628., 6456., 9939.,  11217., 10569., 11919., 8220., 9144.,
      6416., 7032., 10790., 11738., 11354., 12350., 8464., 9144.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    11.,   28.,   48.,   68.,   88.,   67.,   81.,   58.,   86.,
      232.,  304.,  376.,  448.,  294.,  338.,  255.,  321.,  804.,  960.,
      1116., 1272., 777.,  867.,  579.,  693.,  1548., 1800., 2052., 2304.,
      1293., 1431., 850.,  942.,  2040., 2240., 2440., 2640., 1438., 1546.,
      689.,  743.,  1588., 1704., 1820., 1936., 1039., 1101.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2056.,  2856.,  5044.,  6436.,  7204.,  8980.,  7048.,  8360.,
      8700.,  10668., 18006., 21246., 22974., 26790., 20028., 22764.,
      20412., 23916., 37878., 43422., 42846., 48966., 34812., 39084.,
      32124., 37164., 57750., 65598., 62718., 71142., 49596., 55404.,
      43836., 50412., 77622., 87774., 82590., 93318., 64380., 71724.,
      50376., 55272., 84820., 92356., 89284., 97204., 66632., 72040.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   70.,   180.,   324.,   468.,   612.,   486.,   590.,
      380.,  588.,  1640.,  2184.,  2728.,  3272.,  2188.,  2524.,
      1818., 2322., 5916.,  7116.,  8316.,  9516.,  5874.,  6570.,
      4362., 5250., 11772., 13740., 15708., 17676., 9954.,  11034.,
      6556., 7276., 15784., 17352., 18920., 20488., 11180., 12028.,
      5358., 5782., 12372., 13284., 14196., 15108., 8118.,  8606.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      74.,   88.,   102.,  116.,  176.,  200.,  224.,  248.,  242.,  272.,
      302.,  332.,  234.,  256.,  278.,  300.,  297.,  330.,  363.,  396.,
      606.,  660.,  714.,  768.,  759.,  822.,  885.,  948.,  657.,  702.,
      747.,  792.,  657.,  714.,  771.,  828.,  1218., 1308., 1398., 1488.,
      1371., 1470., 1569., 1668., 1113., 1182., 1251., 1320., 1017., 1098.,
      1179., 1260., 1830., 1956., 2082., 2208., 1983., 2118., 2253., 2388.,
      1569., 1662., 1755., 1848., 1377., 1482., 1587., 1692., 2442., 2604.,
      2766., 2928., 2595., 2766., 2937., 3108., 2025., 2142., 2259., 2376.,
      1586., 1664., 1742., 1820., 2672., 2792., 2912., 3032., 2810., 2936.,
      3062., 3188., 2098., 2184., 2270., 2356.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,   7.,   10.,  13.,  16.,  19.,  22.,  25.,  28.,
      18.,  20.,  22.,  24.,  16.,  20.,  24.,  28.,  62.,  72.,  82.,  92.,
      102., 112., 122., 132., 78.,  84.,  90.,  96.,  69.,  78.,  87.,  96.,
      213., 234., 255., 276., 297., 318., 339., 360., 204., 216., 228., 240.,
      147., 162., 177., 192., 393., 426., 459., 492., 525., 558., 591., 624.,
      330., 348., 366., 384., 216., 228., 240., 252., 518., 544., 570., 596.,
      622., 648., 674., 700., 366., 380., 394., 408., 175., 182., 189., 196.,
      403., 418., 433., 448., 463., 478., 493., 508., 264., 272., 280., 288.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      496.,   600.,   704.,   808.,   1234.,  1414.,  1594.,  1774.,  1750.,
      1978.,  2206.,  2434.,  1728.,  1896.,  2064.,  2232.,  2136.,  2388.,
      2640.,  2892.,  4443.,  4857.,  5271.,  5685.,  5649.,  6135.,  6621.,
      7107.,  4944.,  5292.,  5640.,  5988.,  4968.,  5412.,  5856.,  6300.,
      9267.,  9969.,  10671., 11373., 10473., 11247., 12021., 12795., 8544.,
      9084.,  9624.,  10164., 7800.,  8436.,  9072.,  9708.,  14091., 15081.,
      16071., 17061., 15297., 16359., 17421., 18483., 12144., 12876., 13608.,
      14340., 10632., 11460., 12288., 13116., 18915., 20193., 21471., 22749.,
      20121., 21471., 22821., 24171., 15744., 16668., 17592., 18516., 12368.,
      12984., 13600., 14216., 20866., 21814., 22762., 23710., 21958., 22954.,
      23950., 24946., 16416., 17096., 17776., 18456.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    11.,   17.,   23.,   40.,   60.,   80.,   100.,  120.,  140.,
      160.,  180.,  123.,  137.,  151.,  165.,  94.,   122.,  150.,  178.,
      408.,  480.,  552.,  624.,  696.,  768.,  840.,  912.,  554.,  598.,
      642.,  686.,  459.,  525.,  591.,  657.,  1488., 1644., 1800., 1956.,
      2112., 2268., 2424., 2580., 1485., 1575., 1665., 1755., 1071., 1185.,
      1299., 1413., 2904., 3156., 3408., 3660., 3912., 4164., 4416., 4668.,
      2481., 2619., 2757., 2895., 1630., 1722., 1814., 1906., 3928., 4128.,
      4328., 4528., 4728., 4928., 5128., 5328., 2794., 2902., 3010., 3118.,
      1337., 1391., 1445., 1499., 3088., 3204., 3320., 3436., 3552., 3668.,
      3784., 3900., 2031., 2093., 2155., 2217.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3592.,   4392.,   5192.,   5992.,   9188.,   10580.,  11972.,  13364.,
      13268.,  15044.,  16820.,  18596.,  13256.,  14568.,  15880.,  17192.,
      16140.,  18108.,  20076.,  22044.,  33942.,  37182.,  40422.,  43662.,
      43518.,  47334.,  51150.,  54966.,  38316.,  41052.,  43788.,  46524.,
      38604.,  42108.,  45612.,  49116.,  72246.,  77790.,  83334.,  88878.,
      81822.,  87942.,  94062.,  100182., 66924.,  71196.,  75468.,  79740.,
      61068.,  66108.,  71148.,  76188.,  110550., 118398., 126246., 134094.,
      120126., 128550., 136974., 145398., 95532.,  101340., 107148., 112956.,
      83532.,  90108.,  96684.,  103260., 148854., 159006., 169158., 179310.,
      158430., 169158., 179886., 190614., 124140., 131484., 138828., 146172.,
      97672.,  102568., 107464., 112360., 164900., 172436., 179972., 187508.,
      173588., 181508., 189428., 197348., 129864., 135272., 140680., 146088.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    70.,    110.,   150.,   260.,   404.,   548.,   692.,   836.,
      980.,   1124.,  1268.,  902.,   1006.,  1110.,  1214.,  620.,   828.,
      1036.,  1244.,  2920.,  3464.,  4008.,  4552.,  5096.,  5640.,  6184.,
      6728.,  4156.,  4492.,  4828.,  5164.,  3306.,  3810.,  4314.,  4818.,
      11052., 12252., 13452., 14652., 15852., 17052., 18252., 19452., 11298.,
      11994., 12690., 13386., 8154.,  9042.,  9930.,  10818., 22284., 24252.,
      26220., 28188., 30156., 32124., 34092., 36060., 19218., 20298., 21378.,
      22458., 12652., 13372., 14092., 14812., 30568., 32136., 33704., 35272.,
      36840., 38408., 39976., 41544., 21820., 22668., 23516., 24364., 10446.,
      10870., 11294., 11718., 24164., 25076., 25988., 26900., 27812., 28724.,
      29636., 30548., 15926., 16414., 16902., 17390.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      32.,  68.,  89.,  110., 96.,  114., 219., 264., 309.,  252.,
      249., 444., 489., 534., 417., 384., 669., 714., 759.,  582.,
      519., 894., 939., 984., 747., 560., 929., 968., 1007., 740.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,   10.,  12.,  9.,   8.,  26.,  56.,  54.,  36.,
      30., 84.,  165., 144., 90.,  66., 165., 300., 243., 144.,
      89., 206., 353., 270., 153., 70., 157., 262., 195., 108.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      204.,  454.,  610.,  766.,  684.,  786.,  1545., 1887., 2229., 1842.,
      1806., 3255., 3597., 3939., 3102., 2826., 4965., 5307., 5649., 4362.,
      3846., 6675., 7017., 7359., 5622., 4244., 7066., 7366., 7666., 5652.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   22.,   59.,   78.,   61.,   46.,  164.,  370.,  372.,  254.,
      195., 570.,  1149., 1026., 651.,  465., 1182., 2175., 1782., 1065.,
      658., 1532., 2638., 2028., 1154., 527., 1186., 1985., 1482., 823.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1432.,  3284.,  4484.,  5684.,  5144.,  5796.,  11550., 14214.,
      16878., 14052., 13716., 24870., 27534., 30198., 23892., 21636.,
      38190., 40854., 43518., 33732., 29556., 51510., 54174., 56838.,
      43572., 33016., 55076., 57428., 59780., 44152.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   140.,   394.,   556.,   446.,   300.,   1144.,  2660.,
      2744., 1900.,  1386.,  4164.,  8526.,  7716.,  4938.,  3474.,
      8916., 16518., 13620., 8178.,  5052.,  11800., 20372., 15704.,
      8956., 4086.,  9212.,  15442., 11548., 6422.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      48.,   64.,   109.,  136.,  145.,  178.,  181.,  220.,  164.,  192.,
      189.,  228.,  375.,  438.,  456.,  528.,  537.,  618.,  447.,  504.,
      429.,  498.,  780.,  888.,  861.,  978.,  942.,  1068., 747.,  834.,
      669.,  768.,  1185., 1338., 1266., 1428., 1347., 1518., 1047., 1164.,
      909.,  1038., 1590., 1788., 1671., 1878., 1752., 1968., 1347., 1494.,
      1024., 1120., 1711., 1858., 1783., 1936., 1855., 2014., 1372., 1480.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   5.,   8.,   14.,  20.,  19.,  24.,  15.,  18.,  11.,  16.,
      40.,  52.,  91.,  112., 92.,  108., 63.,  72.,  48.,  60.,  141., 168.,
      285., 330., 255., 288., 162., 180., 111., 132., 285., 330., 528., 600.,
      435., 486., 261., 288., 161., 178., 376., 412., 649., 706., 500., 540.,
      285., 306., 130., 140., 293., 314., 491., 524., 367., 390., 204., 216.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      316.,   436.,   752.,   956.,   1028.,  1280., 1304.,  1604.,  1204.,
      1420.,  1344.,  1644.,  2721.,  3207.,  3351., 3909.,  3981.,  4611.,
      3348.,  3792.,  3204.,  3744.,  5871.,  6717., 6501.,  7419.,  7131.,
      8121.,  5688.,  6372.,  5064.,  5844.,  9021., 10227., 9651.,  10929.,
      10281., 11631., 8028.,  8952.,  6924.,  7944., 12171., 13737., 12801.,
      14439., 13431., 15141., 10368., 11532., 7916., 8676.,  13256., 14420.,
      13820., 15032., 14384., 15644., 10660., 11516.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    11.,   28.,   48.,   85.,   127.,  128.,  164.,  105.,  127.,
      64.,   100.,  260.,  348.,  620.,  776.,  652.,  772.,  456.,  524.,
      321.,  411.,  984.,  1188., 2037., 2379., 1860., 2112., 1197., 1335.,
      807.,  969.,  2100., 2448., 3927., 4485., 3264., 3660., 1971., 2181.,
      1216., 1348., 2852., 3132., 4940., 5384., 3820., 4132., 2184., 2348.,
      995.,  1073., 2248., 2412., 3775., 4033., 2828., 3008., 1575., 1669.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2264.,   3192.,   5548.,  7132.,   7708.,   9676.,   9868.,   12220.,
      9208.,   10904.,  10092., 12444.,  20670.,  24486.,  25638.,  30030.,
      30606.,  35574.,  25884., 29388.,  24732.,  29004.,  45510.,  52206.,
      50478.,  57750.,  55446., 63294.,  44364.,  49788.,  39372.,  45564.,
      70350.,  79926.,  75318., 85470.,  80286.,  91014.,  62844.,  70188.,
      54012.,  62124.,  95190., 107646., 100158., 113190., 105126., 118734.,
      81324.,  90588.,  62232., 68280.,  104332., 113596., 108796., 118444.,
      113260., 123292., 84024., 90840.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    70.,    180.,   324.,   578.,   890.,   932.,   1204.,  782.,
      950.,   420.,   692.,   1848.,  2520.,  4540.,  5740.,  4888.,  5816.,
      3460.,  3988.,  2322.,  3018.,  7308.,  8892.,  15342., 18006., 14172.,
      16140., 9186.,  10266., 6138.,  7410.,  16092., 18828., 30246., 34638.,
      25260., 28380., 15306., 16962., 9444.,  10484., 22200., 24408., 38524.,
      42028., 29848., 32312., 17092., 18388., 7782.,  8398.,  17604., 18900.,
      29594., 31634., 22196., 23620., 12374., 13118.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      80.,   96.,   112.,  128.,  191.,  218.,  245.,  272.,  257.,  290.,
      323.,  356.,  323.,  362.,  401.,  440.,  300.,  328.,  356.,  384.,
      339.,  378.,  417.,  456.,  687.,  750.,  813.,  876.,  840.,  912.,
      984.,  1056., 993.,  1074., 1155., 1236., 837.,  894.,  951.,  1008.,
      789.,  858.,  927.,  996.,  1452., 1560., 1668., 1776., 1605., 1722.,
      1839., 1956., 1758., 1884., 2010., 2136., 1407., 1494., 1581., 1668.,
      1239., 1338., 1437., 1536., 2217., 2370., 2523., 2676., 2370., 2532.,
      2694., 2856., 2523., 2694., 2865., 3036., 1977., 2094., 2211., 2328.,
      1689., 1818., 1947., 2076., 2982., 3180., 3378., 3576., 3135., 3342.,
      3549., 3756., 3288., 3504., 3720., 3936., 2547., 2694., 2841., 2988.,
      1952., 2048., 2144., 2240., 3275., 3422., 3569., 3716., 3413., 3566.,
      3719., 3872., 3551., 3710., 3869., 4028., 2636., 2744., 2852., 2960.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    2.,    3.,    4.,    7.,    10.,   13.,   16.,   22.,  28.,  34.,
      40.,   33.,   38.,   43.,   48.,   27.,   30.,   33.,   36.,  17.,  22.,
      27.,   32.,   68.,   80.,   92.,   104.,  161.,  182.,  203., 224., 168.,
      184.,  200.,  216.,  117.,  126.,  135.,  144.,  84.,   96.,  108., 120.,
      255.,  282.,  309.,  336.,  525.,  570.,  615.,  660.,  477., 510., 543.,
      576.,  306.,  324.,  342.,  360.,  201.,  222.,  243.,  264., 525., 570.,
      615.,  660.,  984.,  1056., 1128., 1200., 819.,  870.,  921., 972., 495.,
      522.,  549.,  576.,  305.,  322.,  339.,  356.,  716.,  752., 788., 824.,
      1241., 1298., 1355., 1412., 960.,  1000., 1040., 1080., 549., 570., 591.,
      612.,  250.,  260.,  270.,  280.,  565.,  586.,  607.,  628., 949., 982.,
      1015., 1048., 711.,  734.,  757.,  780.,  396.,  408.,  420., 432.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      540.,   660.,   780.,   900.,   1348.,  1552.,  1756.,  1960.,  1864.,
      2116.,  2368.,  2620.,  2380.,  2680.,  2980.,  3280.,  2244.,  2460.,
      2676.,  2892.,  2460.,  2760.,  3060.,  3360.,  5073.,  5559.,  6045.,
      6531.,  6279.,  6837.,  7395.,  7953.,  7485.,  8115.,  8745.,  9375.,
      6360.,  6804.,  7248.,  7692.,  6000.,  6540.,  7080.,  7620.,  11103.,
      11949., 12795., 13641., 12309., 13227., 14145., 15063., 13515., 14505.,
      15495., 16485., 10860., 11544., 12228., 12912., 9540.,  10320., 11100.,
      11880., 17133., 18339., 19545., 20751., 18339., 19617., 20895., 22173.,
      19545., 20895., 22245., 23595., 15360., 16284., 17208., 18132., 13080.,
      14100., 15120., 16140., 23163., 24729., 26295., 27861., 24369., 26007.,
      27645., 29283., 25575., 27285., 28995., 30705., 19860., 21024., 22188.,
      23352., 15260., 16020., 16780., 17540., 25636., 26800., 27964., 29128.,
      26728., 27940., 29152., 30364., 27820., 29080., 30340., 31600., 20676.,
      21532., 22388., 23244.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,     11.,    17.,   23.,   40.,   60.,   80.,   100.,  137.,  179.,
      221.,   263.,   228.,  264.,  300.,  336.,  193.,  215.,  237.,  259.,
      100.,   136.,   172.,  208.,  452.,  540.,  628.,  716.,  1120., 1276.,
      1432.,  1588.,  1212., 1332., 1452., 1572., 860.,  928.,  996.,  1064.,
      573.,   663.,   753.,  843.,  1812., 2016., 2220., 2424., 3813., 4155.,
      4497.,  4839.,  3528., 3780., 4032., 4284., 2289., 2427., 2565., 2703.,
      1491.,  1653.,  1815., 1977., 3936., 4284., 4632., 4980., 7431., 7989.,
      8547.,  9105.,  6228., 6624., 7020., 7416., 3783., 3993., 4203., 4413.,
      2332.,  2464.,  2596., 2728., 5492., 5772., 6052., 6332., 9544., 9988.,
      10432., 10876., 7404., 7716., 8028., 8340., 4244., 4408., 4572., 4736.,
      1931.,  2009.,  2087., 2165., 4372., 4536., 4700., 4864., 7355., 7613.,
      7871.,  8129.,  5520., 5700., 5880., 6060., 3079., 3173., 3267., 3361.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3928.,   4856.,   5784.,   6712.,   10076.,  11660.,  13244.,  14828.,
      14156.,  16124.,  18092.,  20060.,  18236.,  20588.,  22940.,  25292.,
      17336.,  19032.,  20728.,  22424.,  18684.,  21036.,  23388.,  25740.,
      38910.,  42726.,  46542.,  50358.,  48486.,  52878.,  57270.,  61662.,
      58062.,  63030.,  67998.,  72966.,  49548.,  53052.,  56556.,  60060.,
      46764.,  51036.,  55308.,  59580.,  86790.,  93486.,  100182., 106878.,
      96366.,  103638., 110910., 118182., 105942., 113790., 121638., 129486.,
      85308.,  90732.,  96156.,  101580., 74844.,  81036.,  87228.,  93420.,
      134670., 144246., 153822., 163398., 144246., 154398., 164550., 174702.,
      153822., 164550., 175278., 186006., 121068., 128412., 135756., 143100.,
      102924., 111036., 119148., 127260., 182550., 195006., 207462., 219918.,
      192126., 205158., 218190., 231222., 201702., 215310., 228918., 242526.,
      156828., 166092., 175356., 184620., 120664., 126712., 132760., 138808.,
      202844., 212108., 221372., 230636., 211532., 221180., 230828., 240476.,
      220220., 230252., 240284., 250316., 163768., 170584., 177400., 184216.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    70.,    110.,   150.,   260.,   404.,   548.,   692.,   946.,
      1258.,  1570.,  1882.,  1684.,  1956.,  2228.,  2500.,  1454.,  1622.,
      1790.,  1958.,  660.,   932.,   1204.,  1476.,  3256.,  3928.,  4600.,
      5272.,  8300.,  9500.,  10700., 11900., 9176.,  10104., 11032., 11960.,
      6580.,  7108.,  7636.,  8164.,  4194.,  4890.,  5586.,  6282.,  13596.,
      15180., 16764., 18348., 28974., 31638., 34302., 36966., 27084., 29052.,
      31020., 32988., 17682., 18762., 19842., 20922., 11466., 12738., 14010.,
      15282., 30444., 33180., 35916., 38652., 57702., 62094., 66486., 70878.,
      48540., 51660., 54780., 57900., 29562., 31218., 32874., 34530., 18228.,
      19268., 20308., 21348., 43000., 45208., 47416., 49624., 74828., 78332.,
      81836., 85340., 58136., 60600., 63064., 65528., 33364., 34660., 35956.,
      37252., 15174., 15790., 16406., 17022., 34388., 35684., 36980., 38276.,
      57898., 59938., 61978., 64018., 43492., 44916., 46340., 47764., 24278.,
      25022., 25766., 26510.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      35.,   74.,   95.,  116., 137.,  117.,  129.,  246.,  291.,
      336.,  381.,  306., 291., 516.,  561.,  606.,  651.,  504.,
      453.,  786.,  831., 876., 921.,  702.,  615.,  1056., 1101.,
      1146., 1191., 900., 665., 1100., 1139., 1178., 1217., 891.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   4.,   10.,  16.,  17.,  12.,  9.,  29.,  62.,  83.,  75.,  48.,
      36.,  99.,  192., 237., 198., 120., 84., 207., 372., 417., 330., 192.,
      115., 263., 446., 485., 365., 204., 91., 202., 334., 358., 263., 144.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      224.,  496.,  652.,  808.,  964.,  840.,  894.,  1743., 2085.,
      2427., 2769., 2250., 2118., 3795., 4137., 4479., 4821., 3762.,
      3342., 5847., 6189., 6531., 6873., 5274., 4566., 7899., 8241.,
      8583., 8925., 6786., 5048., 8380., 8680., 8980., 9280., 6816.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    22.,   59.,   101.,  114.,  83.,   52.,   184.,  412.,
      568.,  528.,  344.,  237.,  678.,  1347., 1689., 1434., 879.,
      597.,  1494., 2715., 3057., 2442., 1431., 856.,  1968., 3352.,
      3652., 2760., 1548., 689.,  1534., 2543., 2729., 2010., 1103.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1576.,  3596.,  4796.,  5996.,  7196.,  6344.,  6612.,  13062., 15726.,
      18390., 21054., 17220., 16116., 29046., 31710., 34374., 37038., 29028.,
      25620., 45030., 47694., 50358., 53022., 40836., 35124., 61014., 63678.,
      66342., 69006., 52644., 39304., 65372., 67724., 70076., 72428., 53288.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    140.,   394.,   706.,   828.,   614.,   340.,   1288.,  2972.,
      4172.,  3944.,  2596.,  1698.,  4980.,  10038., 12702., 10884., 6714.,
      4482.,  11316., 20694., 23358., 18756., 11034., 6596.,  15208., 25964.,
      28316., 21448., 12052., 5358.,  11948., 19834., 21298., 15708., 8630.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      52.,   70.,   118.,  148.,  154.,  190.,  190.,  232.,  226.,
      274.,  200.,  234.,  213.,  258.,  420.,  492.,  501.,  582.,
      582.,  672.,  663.,  762.,  543.,  612.,  501.,  582.,  906.,
      1032., 987.,  1122., 1068., 1212., 1149., 1302., 903.,  1008.,
      789.,  906.,  1392., 1572., 1473., 1662., 1554., 1752., 1635.,
      1842., 1263., 1404., 1077., 1230., 1878., 2112., 1959., 2202.,
      2040., 2292., 2121., 2382., 1623., 1800., 1216., 1330., 2026.,
      2200., 2098., 2278., 2170., 2356., 2242., 2434., 1652., 1782.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   5.,   8.,   14.,  20.,  23.,  32.,  27.,  34.,  20.,  24.,
      12.,  18.,  44.,  58.,  100., 124., 136., 166., 128., 150., 84.,  96.,
      57.,  72.,  165., 198., 330., 384., 411., 474., 351., 396., 216., 240.,
      141., 168., 357., 414., 654., 744., 735., 834., 591., 660., 348., 384.,
      208., 230., 480., 526., 820., 892., 892., 970., 676., 730., 380., 408.,
      169., 182., 377., 404., 626., 668., 671., 716., 495., 526., 272., 288.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      344.,   480.,   818.,   1046.,  1094.,  1370.,  1370.,  1694.,  1646.,
      2018.,  1480.,  1744.,  1524.,  1872.,  3063.,  3621.,  3693.,  4323.,
      4323.,  5025.,  4953.,  5727.,  4092.,  4632.,  3756.,  4392.,  6843.,
      7833.,  7473.,  8535.,  8103.,  9237.,  8733.,  9939.,  6900.,  7728.,
      5988.,  6912.,  10623., 12045., 11253., 12747., 11883., 13449., 12513.,
      14151., 9708.,  10824., 8220.,  9432.,  14403., 16257., 15033., 16959.,
      15663., 17661., 16293., 18363., 12516., 13920., 9416.,  10320., 15722.,
      17102., 16286., 17714., 16850., 18326., 17414., 18938., 12856., 13888.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    11.,   28.,   48.,   85.,   127.,  151.,  217.,  188.,
      240.,  143.,  173.,  70.,   114.,  288.,  392.,  686.,  866.,
      962.,  1190., 928.,  1096., 618.,  710.,  387.,  501.,  1164.,
      1416., 2379., 2793., 3009., 3495., 2604., 2952., 1617., 1803.,
      1035., 1245., 2652., 3096., 4899., 5601., 5529., 6303., 4476.,
      5016., 2649., 2931., 1582., 1754., 3664., 4024., 6278., 6842.,
      6842., 7454., 5200., 5624., 2930., 3150., 1301., 1403., 2908.,
      3120., 4837., 5167., 5191., 5545., 3836., 4080., 2111., 2237.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2472.,   3528.,   6052.,   7828.,   8212.,   10372.,  10372.,  12916.,
      12532.,  15460.,  11368.,  13448.,  11484.,  14220.,  23334.,  27726.,
      28302.,  33270.,  33270.,  38814.,  38238.,  44358.,  31740.,  36012.,
      29052.,  34092.,  53142.,  60990.,  58110.,  66534.,  63078.,  72078.,
      68046.,  77622.,  53916.,  60492.,  46620.,  53964.,  82950.,  94254.,
      87918.,  99798.,  92886.,  105342., 97854.,  110886., 76092.,  84972.,
      64188.,  73836.,  112758., 127518., 117726., 133062., 122694., 138606.,
      127662., 144150., 98268.,  109452., 74088.,  81288.,  123844., 134836.,
      128308., 139684., 132772., 144532., 137236., 149380., 101416., 109640.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    70.,    180.,   324.,   578.,   890.,   1082.,  1586.,  1396.,
      1796.,  1078.,  1310.,  460.,   796.,   2056.,  2856.,  5044.,  6436.,
      7204.,  8980.,  7048.,  8360.,  4732.,  5452.,  2826.,  3714.,  8700.,
      10668., 18006., 21246., 22974., 26790., 20028., 22764., 12498., 13962.,
      7914.,  9570.,  20412., 23916., 37878., 43422., 42846., 48966., 34812.,
      39084., 20658., 22890., 12332., 13692., 28616., 31464., 49108., 53572.,
      53572., 58420., 40776., 44136., 23004., 24748., 10206., 11014., 22836.,
      24516., 38018., 40634., 40826., 43634., 30196., 32132., 16630., 17630.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      86.,   104.,  122.,  140.,  206.,  236.,  266.,  296.,  272.,  308.,
      344.,  380.,  338.,  380.,  422.,  464.,  404.,  452.,  500.,  548.,
      366.,  400.,  434.,  468.,  381.,  426.,  471.,  516.,  768.,  840.,
      912.,  984.,  921.,  1002., 1083., 1164., 1074., 1164., 1254., 1344.,
      1227., 1326., 1425., 1524., 1017., 1086., 1155., 1224., 921.,  1002.,
      1083., 1164., 1686., 1812., 1938., 2064., 1839., 1974., 2109., 2244.,
      1992., 2136., 2280., 2424., 2145., 2298., 2451., 2604., 1701., 1806.,
      1911., 2016., 1461., 1578., 1695., 1812., 2604., 2784., 2964., 3144.,
      2757., 2946., 3135., 3324., 2910., 3108., 3306., 3504., 3063., 3270.,
      3477., 3684., 2385., 2526., 2667., 2808., 2001., 2154., 2307., 2460.,
      3522., 3756., 3990., 4224., 3675., 3918., 4161., 4404., 3828., 4080.,
      4332., 4584., 3981., 4242., 4503., 4764., 3069., 3246., 3423., 3600.,
      2318., 2432., 2546., 2660., 3878., 4052., 4226., 4400., 4016., 4196.,
      4376., 4556., 4154., 4340., 4526., 4712., 4292., 4484., 4676., 4868.,
      3174., 3304., 3434., 3564.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    2.,    3.,    4.,    7.,    10.,   13.,   16.,   22.,   28.,
      34.,   40.,   37.,   46.,   55.,   64.,   47.,   54.,   61.,   68.,
      36.,   40.,   44.,   48.,   18.,   24.,   30.,   36.,   74.,   88.,
      102.,  116.,  176.,  200.,  224.,  248.,  242.,  272.,  302.,  332.,
      234.,  256.,  278.,  300.,  156.,  168.,  180.,  192.,  99.,   114.,
      129.,  144.,  297.,  330.,  363.,  396.,  606.,  660.,  714.,  768.,
      759.,  822.,  885.,  948.,  657.,  702.,  747.,  792.,  408.,  432.,
      456.,  480.,  255.,  282.,  309.,  336.,  657.,  714.,  771.,  828.,
      1218., 1308., 1398., 1488., 1371., 1470., 1569., 1668., 1113., 1182.,
      1251., 1320., 660.,  696.,  732.,  768.,  394.,  416.,  438.,  460.,
      914.,  960.,  1006., 1052., 1568., 1640., 1712., 1784., 1706., 1784.,
      1862., 1940., 1298., 1352., 1406., 1460., 732.,  760.,  788.,  816.,
      325.,  338.,  351.,  364.,  727.,  754.,  781.,  808.,  1210., 1252.,
      1294., 1336., 1297., 1342., 1387., 1432., 959.,  990.,  1021., 1052.,
      528.,  544.,  560.,  576.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      584.,   720.,   856.,   992.,   1462.,  1690.,  1918.,  2146.,  1978.,
      2254.,  2530.,  2806.,  2494.,  2818.,  3142.,  3466.,  3010.,  3382.,
      3754.,  4126.,  2760.,  3024.,  3288.,  3552.,  2784.,  3132.,  3480.,
      3828.,  5703.,  6261.,  6819.,  7377.,  6909.,  7539.,  8169.,  8799.,
      8115.,  8817.,  9519.,  10221., 9321.,  10095., 10869., 11643., 7776.,
      8316.,  8856.,  9396.,  7032.,  7668.,  8304.,  8940.,  12939., 13929.,
      14919., 15909., 14145., 15207., 16269., 17331., 15351., 16485., 17619.,
      18753., 16557., 17763., 18969., 20175., 13176., 14004., 14832., 15660.,
      11280., 12204., 13128., 14052., 20175., 21597., 23019., 24441., 21381.,
      22875., 24369., 25863., 22587., 24153., 25719., 27285., 23793., 25431.,
      27069., 28707., 18576., 19692., 20808., 21924., 15528., 16740., 17952.,
      19164., 27411., 29265., 31119., 32973., 28617., 30543., 32469., 34395.,
      29823., 31821., 33819., 35817., 31029., 33099., 35169., 37239., 23976.,
      25380., 26784., 28188., 18152., 19056., 19960., 20864., 30406., 31786.,
      33166., 34546., 31498., 32926., 34354., 35782., 32590., 34066., 35542.,
      37018., 33682., 35206., 36730., 38254., 24936., 25968., 27000., 28032.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,     11.,    17.,    23.,    40.,    60.,    80.,    100.,   137.,
      179.,   221.,   263.,   251.,   317.,   383.,   449.,   336.,   388.,
      440.,   492.,   263.,   293.,   323.,   353.,   106.,   150.,   194.,
      238.,   496.,   600.,   704.,   808.,   1234.,  1414.,  1594.,  1774.,
      1750.,  1978.,  2206.,  2434.,  1728.,  1896.,  2064.,  2232.,  1166.,
      1258.,  1350.,  1442.,  687.,   801.,   915.,   1029.,  2136.,  2388.,
      2640.,  2892.,  4443.,  4857.,  5271.,  5685.,  5649.,  6135.,  6621.,
      7107.,  4944.,  5292.,  5640.,  5988.,  3093.,  3279.,  3465.,  3651.,
      1911.,  2121.,  2331.,  2541.,  4968.,  5412.,  5856.,  6300.,  9267.,
      9969.,  10671., 11373., 10473., 11247., 12021., 12795., 8544.,  9084.,
      9624.,  10164., 5085.,  5367.,  5649.,  5931.,  3034.,  3206.,  3378.,
      3550.,  7056.,  7416.,  7776.,  8136.,  12130., 12694., 13258., 13822.,
      13222., 13834., 14446., 15058., 10080., 10504., 10928., 11352., 5694.,
      5914.,  6134.,  6354.,  2525.,  2627.,  2729.,  2831.,  5656.,  5868.,
      6080.,  6292.,  9425.,  9755.,  10085., 10415., 10115., 10469., 10823.,
      11177., 7488.,  7732.,  7976.,  8220.,  4127.,  4253.,  4379.,  4505.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4264.,   5320.,   6376.,   7432.,   10964.,  12740.,  14516.,  16292.,
      15044.,  17204.,  19364.,  21524.,  19124.,  21668.,  24212.,  26756.,
      23204.,  26132.,  29060.,  31988.,  21416.,  23496.,  25576.,  27656.,
      21228.,  23964.,  26700.,  29436.,  43878.,  48270.,  52662.,  57054.,
      53454.,  58422.,  63390.,  68358.,  63030.,  68574.,  74118.,  79662.,
      72606.,  78726.,  84846.,  90966.,  60780.,  65052.,  69324.,  73596.,
      54924.,  59964.,  65004.,  70044.,  101334., 109182., 117030., 124878.,
      110910., 119334., 127758., 136182., 120486., 129486., 138486., 147486.,
      130062., 139638., 149214., 158790., 103692., 110268., 116844., 123420.,
      88620.,  95964.,  103308., 110652., 158790., 170094., 181398., 192702.,
      168366., 180246., 192126., 204006., 177942., 190398., 202854., 215310.,
      187518., 200550., 213582., 226614., 146604., 155484., 164364., 173244.,
      122316., 131964., 141612., 151260., 216246., 231006., 245766., 260526.,
      225822., 241158., 256494., 271830., 235398., 251310., 267222., 283134.,
      244974., 261462., 277950., 294438., 189516., 200700., 211884., 223068.,
      143656., 150856., 158056., 165256., 240788., 251780., 262772., 273764.,
      249476., 260852., 272228., 283604., 258164., 269924., 281684., 293444.,
      266852., 278996., 291140., 303284., 197672., 205896., 214120., 222344.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    70.,    110.,    150.,    260.,    404.,    548.,    692.,
      946.,   1258.,  1570.,   1882.,   1834.,   2338.,   2842.,   3346.,
      2532.,  2932.,  3332.,   3732.,   2006.,   2238.,   2470.,   2702.,
      700.,   1036.,  1372.,   1708.,   3592.,   4392.,   5192.,   5992.,
      9188.,  10580., 11972.,  13364.,  13268.,  15044.,  16820.,  18596.,
      13256., 14568., 15880.,  17192.,  9004.,   9724.,   10444.,  11164.,
      5082.,  5970.,  6858.,   7746.,   16140.,  18108.,  20076.,  22044.,
      33942., 37182., 40422.,  43662.,  43518.,  47334.,  51150.,  54966.,
      38316., 41052., 43788.,  46524.,  24066.,  25530.,  26994.,  28458.,
      14778., 16434., 18090.,  19746.,  38604.,  42108.,  45612.,  49116.,
      72246., 77790., 83334.,  88878.,  81822.,  87942.,  94062.,  100182.,
      66924., 71196., 75468.,  79740.,  39906.,  42138.,  44370.,  46602.,
      23804., 25164., 26524.,  27884.,  55432.,  58280.,  61128.,  63976.,
      95396., 99860., 104324., 108788., 104084., 108932., 113780., 118628.,
      79432., 82792., 86152.,  89512.,  44908.,  46652.,  48396.,  50140.,
      19902., 20710., 21518.,  22326.,  44612.,  46292.,  47972.,  49652.,
      74386., 77002., 79618.,  82234.,  79882.,  82690.,  85498.,  88306.,
      59172., 61108., 63044.,  64980.,  32630.,  33630.,  34630.,  35630.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29.,   62.,   83.,   75.,   99.,   192.,  237.,  198.,  207.,  372.,
      417.,  330.,  263.,  446.,  485.,  365.,  221.,  398.,  419.,  331.,
      531.,  912.,  957.,  726.,  639.,  1092., 1137., 858.,  647.,  1070.,
      1109., 813.,  413.,  734.,  755.,  587.,  963.,  1632., 1677., 1254.,
      1071., 1812., 1857., 1386., 1031., 1694., 1733., 1261.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,   7.,   6.,   7.,   23.,  33.,  24.,  19., 53.,  63.,  42.,
      21., 52.,  59.,  36.,  5.,   16.,  27.,  18.,  27., 71.,  97.,  60.,
      63., 149., 175., 102., 49.,  112., 127., 72.,  9.,  28.,  47.,  30.,
      47., 119., 161., 96.,  107., 245., 287., 162., 77., 172., 195., 108.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      184.,  412.,   568.,   528.,   678.,  1347.,  1689.,  1434.,
      1494., 2715.,  3057.,  2442.,  1968., 3352.,  3652.,  2760.,
      1592., 2908.,  3064.,  2448.,  3942., 6819.,  7161.,  5466.,
      4758., 8187.,  8529.,  6474.,  4912., 8152.,  8452.,  6216.,
      3000., 5404.,  5560.,  4368.,  7206., 12291., 12633., 9498.,
      8022., 13659., 14001., 10506., 7856., 12952., 13252., 9672.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   22.,   42.,   39.,   40.,  144.,  216.,  164., 124.,  360.,
      432., 296.,  149.,  374.,  426., 263.,  29.,   102., 186.,  127.,
      184., 496.,  696.,  436.,  460., 1096., 1296., 760., 365.,  838.,
      954., 543.,  53.,   182.,  330., 215.,  328.,  848., 1176., 708.,
      796., 1832., 2160., 1224., 581., 1302., 1482., 823.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1288.,  2972.,   4172.,   3944.,  4980.,  10038.,  12702.,  10884.,
      11316., 20694.,  23358.,  18756., 15208., 25964.,  28316.,  21448.,
      12040., 22172.,  23372.,  18792., 30324., 52662.,  55326.,  42372.,
      36660., 63318.,  65982.,  50244., 38248., 63596.,  65948.,  48584.,
      22792., 41372.,  42572.,  33640., 55668., 95286.,  97950.,  73860.,
      62004., 105942., 108606., 81732., 61288., 101228., 103580., 75720.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   140.,   284.,   278.,  260.,  1000.,  1544.,  1204., 884.,  2632.,
      3176., 2212.,  1118.,  2828., 3228., 2006.,  190.,   716.,  1372., 950.,
      1348., 3688.,  5256.,  3316., 3508., 8392.,  9960.,  5860., 2814., 6476.,
      7388., 4214.,  350.,   1292., 2460., 1622.,  2436.,  6376., 8968., 5428.,
      6132., 14152., 16744., 9508., 4510., 10124., 11548., 6422.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      44.,   58.,   100.,  124.,  136.,  166.,  128.,  150.,  165.,  198.,
      330.,  384.,  411.,  474.,  351.,  396.,  357.,  414.,  654.,  744.,
      735.,  834.,  591.,  660.,  480.,  526.,  820.,  892.,  892.,  970.,
      676.,  730.,  364.,  442.,  676.,  796.,  712.,  838.,  576.,  662.,
      933.,  1062., 1626., 1824., 1707., 1914., 1311., 1452., 1125., 1278.,
      1950., 2184., 2031., 2274., 1551., 1716., 1184., 1294., 1972., 2140.,
      2044., 2218., 1508., 1626., 684.,  826.,  1252., 1468., 1288., 1510.,
      1024., 1174., 1701., 1926., 2922., 3264., 3003., 3354., 2271., 2508.,
      1893., 2142., 3246., 3624., 3327., 3714., 2511., 2772., 1888., 2062.,
      3124., 3388., 3196., 3466., 2340., 2522.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   5.,   8.,   11.,  14.,  10.,  12.,  10.,  14.,  36.,  46.,
      56.,  66.,  42.,  48.,  34.,  38.,  96.,  106., 116., 126., 78.,  84.,
      39.,  42.,  97.,  104., 111., 118., 68.,  72.,  5.,   10.,  21.,  32.,
      43.,  54.,  30.,  36.,  42.,  54.,  116., 142., 168., 194., 106., 120.,
      114., 126., 272., 298., 324., 350., 190., 204., 91.,  98.,  209., 224.,
      239., 254., 136., 144., 9.,   18.,  37.,  56.,  75.,  94.,  50.,  60.,
      74.,  94.,  196., 238., 280., 322., 170., 192., 194., 214., 448., 490.,
      532., 574., 302., 324., 143., 154., 321., 344., 367., 390., 204., 216.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      288.,   392.,   686.,   866.,   962.,   1190.,  928.,   1096.,  1164.,
      1416.,  2379.,  2793.,  3009.,  3495.,  2604.,  2952.,  2652.,  3096.,
      4899.,  5601.,  5529.,  6303.,  4476.,  5016.,  3664.,  4024.,  6278.,
      6842.,  6842.,  7454.,  5200.,  5624.,  2720.,  3336.,  5102.,  6050.,
      5378.,  6374.,  4384.,  5064.,  7116.,  8136.,  12459., 14025., 13089.,
      14727., 10092., 11208., 8604.,  9816.,  14979., 16833., 15609., 17535.,
      11964., 13272., 9168.,  10040., 15302., 16634., 15866., 17246., 11728.,
      12664., 5152.,  6280.,  9518.,  11234., 9794.,  11558., 7840.,  9032.,
      13068., 14856., 22539., 25257., 23169., 25959., 17580., 19464., 14556.,
      16536., 25059., 28065., 25689., 28767., 19452., 21528., 14672., 16056.,
      24326., 26426., 24890., 27038., 18256., 19704.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    11.,   28.,   48.,   68.,   88.,   67.,   81.,   58.,   86.,
      232.,  304.,  376.,  448.,  294.,  338.,  226.,  254.,  664.,  736.,
      808.,  880.,  558.,  602.,  281.,  303.,  708.,  760.,  812.,  864.,
      503.,  533.,  29.,   67.,   140.,  224.,  308.,  392.,  219.,  265.,
      298.,  390.,  840.,  1040., 1240., 1440., 790.,  898.,  850.,  942.,
      2040., 2240., 2440., 2640., 1438., 1546., 689.,  743.,  1588., 1704.,
      1820., 1936., 1039., 1101., 53.,   123.,  252.,  400.,  548.,  696.,
      371.,  449.,  538.,  694.,  1448., 1776., 2104., 2432., 1286., 1458.,
      1474., 1630., 3416., 3744., 4072., 4400., 2318., 2490., 1097., 1183.,
      2468., 2648., 2828., 3008., 1575., 1669.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2056.,   2856.,   5044.,   6436.,   7204.,   8980.,   7048.,   8360.,
      8700.,   10668.,  18006.,  21246.,  22974.,  26790.,  20028.,  22764.,
      20412.,  23916.,  37878.,  43422.,  42846.,  48966.,  34812.,  39084.,
      28616.,  31464.,  49108.,  53572.,  53572.,  58420.,  40776.,  44136.,
      21000.,  25896.,  39604.,  47140.,  41764.,  49684.,  34184.,  39592.,
      55548.,  63660.,  97494.,  109950., 102462., 115494., 79164.,  88044.,
      67260.,  76908.,  117366., 132126., 122334., 137670., 93948.,  104364.,
      72136.,  79080.,  120532., 131140., 124996., 135988., 92488.,  99944.,
      39944.,  48936.,  74164.,  87844.,  76324.,  90388.,  61320.,  70824.,
      102396., 116652., 176982., 198654., 181950., 204198., 138300., 153324.,
      114108., 129900., 196854., 220830., 201822., 226374., 153084., 169644.,
      115656., 126696., 191956., 208708., 196420., 213556., 144200., 155752.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    70.,    180.,   324.,   468.,   612.,   486.,   590.,   380.,
      588.,   1640.,  2184.,  2728.,  3272.,  2188.,  2524.,  1628.,  1836.,
      4904.,  5448.,  5992.,  6536.,  4204.,  4540.,  2126.,  2294.,  5396.,
      5796.,  6196.,  6596.,  3862.,  4094.,  190.,   486.,   1012.,  1668.,
      2324.,  2980.,  1670.,  2030.,  2236.,  2956.,  6376.,  7944.,  9512.,
      11080., 6092.,  6940.,  6556.,  7276.,  15784., 17352., 18920., 20488.,
      11180., 12028., 5358.,  5782.,  12372., 13284., 14196., 15108., 8118.,
      8606.,  350.,   902.,   1844.,  3012.,  4180.,  5348.,  2854.,  3470.,
      4092.,  5324.,  11112., 13704., 16296., 18888., 9996.,  11356., 11484.,
      12716., 26664., 29256., 31848., 34440., 18156., 19516., 8590.,  9270.,
      19348., 20772., 22196., 23620., 12374., 13118.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      74.,   88.,   102.,  116.,  176.,  200.,  224.,  248.,  242.,  272.,
      302.,  332.,  234.,  256.,  278.,  300.,  297.,  330.,  363.,  396.,
      606.,  660.,  714.,  768.,  759.,  822.,  885.,  948.,  657.,  702.,
      747.,  792.,  657.,  714.,  771.,  828.,  1218., 1308., 1398., 1488.,
      1371., 1470., 1569., 1668., 1113., 1182., 1251., 1320., 914.,  960.,
      1006., 1052., 1568., 1640., 1712., 1784., 1706., 1784., 1862., 1940.,
      1298., 1352., 1406., 1460., 650.,  728.,  806.,  884.,  1232., 1352.,
      1472., 1592., 1298., 1424., 1550., 1676., 1066., 1152., 1238., 1324.,
      1737., 1866., 1995., 2124., 3054., 3252., 3450., 3648., 3207., 3414.,
      3621., 3828., 2481., 2622., 2763., 2904., 2097., 2250., 2403., 2556.,
      3666., 3900., 4134., 4368., 3819., 4062., 4305., 4548., 2937., 3102.,
      3267., 3432., 2258., 2368., 2478., 2588., 3776., 3944., 4112., 4280.,
      3914., 4088., 4262., 4436., 2898., 3016., 3134., 3252., 1226., 1368.,
      1510., 1652., 2288., 2504., 2720., 2936., 2354., 2576., 2798., 3020.,
      1898., 2048., 2198., 2348., 3177., 3402., 3627., 3852., 5502., 5844.,
      6186., 6528., 5655., 6006., 6357., 6708., 4305., 4542., 4779., 5016.,
      3537., 3786., 4035., 4284., 6114., 6492., 6870., 7248., 6267., 6654.,
      7041., 7428., 4761., 5022., 5283., 5544., 3602., 3776., 3950., 4124.,
      5984., 6248., 6512., 6776., 6122., 6392., 6662., 6932., 4498., 4680.,
      4862., 5044.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   3.,   4.,    7.,    10.,   13.,   16.,  19.,  22.,  25.,
      28.,  18.,  20.,  22.,   24.,   16.,   20.,   24.,  28.,  62.,  72.,
      82.,  92.,  102., 112.,  122.,  132.,  78.,   84.,  90.,  96.,  64.,
      68.,  72.,  76.,  182.,  192.,  202.,  212.,  222., 232., 242., 252.,
      150., 156., 162., 168.,  75.,   78.,   81.,   84.,  187., 194., 201.,
      208., 215., 222., 229.,  236.,  132.,  136.,  140., 144., 5.,   10.,
      15.,  20.,  31.,  42.,   53.,   64.,   75.,   86.,  97.,  108., 54.,
      60.,  66.,  72.,  72.,   84.,   96.,   108.,  206., 232., 258., 284.,
      310., 336., 362., 388.,  198.,  212.,  226.,  240., 216., 228., 240.,
      252., 518., 544., 570.,  596.,  622.,  648.,  674., 700., 366., 380.,
      394., 408., 175., 182.,  189.,  196.,  403.,  418., 433., 448., 463.,
      478., 493., 508., 264.,  272.,  280.,  288.,  9.,   18.,  27.,  36.,
      55.,  74.,  93.,  112.,  131.,  150.,  169.,  188., 90.,  100., 110.,
      120., 128., 148., 168.,  188.,  350.,  392.,  434., 476., 518., 560.,
      602., 644., 318., 340.,  362.,  384.,  368.,  388., 408., 428., 854.,
      896., 938., 980., 1022., 1064., 1106., 1148., 582., 604., 626., 648.,
      275., 286., 297., 308.,  619.,  642.,  665.,  688., 711., 734., 757.,
      780., 396., 408., 420.,  432.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      496.,   600.,   704.,   808.,   1234.,  1414.,  1594.,  1774.,  1750.,
      1978.,  2206.,  2434.,  1728.,  1896.,  2064.,  2232.,  2136.,  2388.,
      2640.,  2892.,  4443.,  4857.,  5271.,  5685.,  5649.,  6135.,  6621.,
      7107.,  4944.,  5292.,  5640.,  5988.,  4968.,  5412.,  5856.,  6300.,
      9267.,  9969.,  10671., 11373., 10473., 11247., 12021., 12795., 8544.,
      9084.,  9624.,  10164., 7056.,  7416.,  7776.,  8136.,  12130., 12694.,
      13258., 13822., 13222., 13834., 14446., 15058., 10080., 10504., 10928.,
      11352., 4976.,  5592.,  6208.,  6824.,  9490.,  10438., 11386., 12334.,
      10006., 11002., 11998., 12994., 8256.,  8936.,  9616.,  10296., 13464.,
      14484., 15504., 16524., 23739., 25305., 26871., 28437., 24945., 26583.,
      28221., 29859., 19344., 20460., 21576., 22692., 16296., 17508., 18720.,
      19932., 28563., 30417., 32271., 34125., 29769., 31695., 33621., 35547.,
      22944., 24252., 25560., 26868., 17680., 18552., 19424., 20296., 29602.,
      30934., 32266., 33598., 30694., 32074., 33454., 34834., 22752., 23688.,
      24624., 25560., 9456.,  10584., 11712., 12840., 17746., 19462., 21178.,
      22894., 18262., 20026., 21790., 23554., 14784., 15976., 17168., 18360.,
      24792., 26580., 28368., 30156., 43035., 45753., 48471., 51189., 44241.,
      47031., 49821., 52611., 33744., 35628., 37512., 39396., 27624., 29604.,
      31584., 33564., 47859., 50865., 53871., 56877., 49065., 52143., 55221.,
      58299., 37344., 39420., 41496., 43572., 28304., 29688., 31072., 32456.,
      47074., 49174., 51274., 53374., 48166., 50314., 52462., 54610., 35424.,
      36872., 38320., 39768.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    11.,   17.,   23.,   40.,   60.,   80.,   100.,  120.,  140.,
      160.,  180.,  123.,  137.,  151.,  165.,  94.,   122.,  150.,  178.,
      408.,  480.,  552.,  624.,  696.,  768.,  840.,  912.,  554.,  598.,
      642.,  686.,  430.,  458.,  486.,  514.,  1272., 1344., 1416., 1488.,
      1560., 1632., 1704., 1776., 1082., 1126., 1170., 1214., 545.,  567.,
      589.,  611.,  1376., 1428., 1480., 1532., 1584., 1636., 1688., 1740.,
      983.,  1013., 1043., 1073., 29.,   67.,   105.,  143.,  216.,  300.,
      384.,  468.,  552.,  636.,  720.,  804.,  403.,  449.,  495.,  541.,
      526.,  618.,  710.,  802.,  1528., 1728., 1928., 2128., 2328., 2528.,
      2728., 2928., 1498., 1606., 1714., 1822., 1630., 1722., 1814., 1906.,
      3928., 4128., 4328., 4528., 4728., 4928., 5128., 5328., 2794., 2902.,
      3010., 3118., 1337., 1391., 1445., 1499., 3088., 3204., 3320., 3436.,
      3552., 3668., 3784., 3900., 2031., 2093., 2155., 2217., 53.,   123.,
      193.,  263.,  392.,  540.,  688.,  836.,  984.,  1132., 1280., 1428.,
      683.,  761.,  839.,  917.,  958.,  1114., 1270., 1426., 2648., 2976.,
      3304., 3632., 3960., 4288., 4616., 4944., 2442., 2614., 2786., 2958.,
      2830., 2986., 3142., 3298., 6584., 6912., 7240., 7568., 7896., 8224.,
      8552., 8880., 4506., 4678., 4850., 5022., 2129., 2215., 2301., 2387.,
      4800., 4980., 5160., 5340., 5520., 5700., 5880., 6060., 3079., 3173.,
      3267., 3361.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3592.,   4392.,   5192.,   5992.,   9188.,   10580.,  11972.,  13364.,
      13268.,  15044.,  16820.,  18596.,  13256.,  14568.,  15880.,  17192.,
      16140.,  18108.,  20076.,  22044.,  33942.,  37182.,  40422.,  43662.,
      43518.,  47334.,  51150.,  54966.,  38316.,  41052.,  43788.,  46524.,
      38604.,  42108.,  45612.,  49116.,  72246.,  77790.,  83334.,  88878.,
      81822.,  87942.,  94062.,  100182., 66924.,  71196.,  75468.,  79740.,
      55432.,  58280.,  61128.,  63976.,  95396.,  99860.,  104324., 108788.,
      104084., 108932., 113780., 118628., 79432.,  82792.,  86152.,  89512.,
      38920.,  43816.,  48712.,  53608.,  74468.,  82004.,  89540.,  97076.,
      78548.,  86468.,  94388.,  102308., 64968.,  70376.,  75784.,  81192.,
      105996., 114108., 122220., 130332., 187158., 199614., 212070., 224526.,
      196734., 209766., 222798., 235830., 152748., 161628., 170508., 179388.,
      128460., 138108., 147756., 157404., 225462., 240222., 254982., 269742.,
      235038., 250374., 265710., 281046., 181356., 191772., 202188., 212604.,
      139912., 146856., 153800., 160744., 234404., 245012., 255620., 266228.,
      243092., 254084., 265076., 276068., 180296., 187752., 195208., 202664.,
      74248.,  83240.,  92232.,  101224., 139748., 153428., 167108., 180788.,
      143828., 157892., 171956., 186020., 116680., 126184., 135688., 145192.,
      195852., 210108., 224364., 238620., 340374., 362046., 383718., 405390.,
      349950., 372198., 394446., 416694., 267180., 282204., 297228., 312252.,
      218316., 234108., 249900., 265692., 378678., 402654., 426630., 450606.,
      388254., 412806., 437358., 461910., 295788., 312348., 328908., 345468.,
      224392., 235432., 246472., 257512., 373412., 390164., 406916., 423668.,
      382100., 399236., 416372., 433508., 281160., 292712., 304264., 315816.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    70.,    110.,   150.,   260.,   404.,   548.,   692.,   836.,
      980.,   1124.,  1268.,  902.,   1006.,  1110.,  1214.,  620.,   828.,
      1036.,  1244.,  2920.,  3464.,  4008.,  4552.,  5096.,  5640.,  6184.,
      6728.,  4156.,  4492.,  4828.,  5164.,  3116.,  3324.,  3532.,  3740.,
      9448.,  9992.,  10536., 11080., 11624., 12168., 12712., 13256., 8188.,
      8524.,  8860.,  9196.,  4142.,  4310.,  4478.,  4646.,  10532., 10932.,
      11332., 11732., 12132., 12532., 12932., 13332., 7574.,  7806.,  8038.,
      8270.,  190.,   486.,   782.,   1078.,  1604.,  2260.,  2916.,  3572.,
      4228.,  4884.,  5540.,  6196.,  3110.,  3470.,  3830.,  4190.,  4012.,
      4732.,  5452.,  6172.,  11752., 13320., 14888., 16456., 18024., 19592.,
      21160., 22728., 11644., 12492., 13340., 14188., 12652., 13372., 14092.,
      14812., 30568., 32136., 33704., 35272., 36840., 38408., 39976., 41544.,
      21820., 22668., 23516., 24364., 10446., 10870., 11294., 11718., 24164.,
      25076., 25988., 26900., 27812., 28724., 29636., 30548., 15926., 16414.,
      16902., 17390., 350.,   902.,   1454.,  2006.,  2948.,  4116.,  5284.,
      6452.,  7620.,  8788.,  9956.,  11124., 5318.,  5934.,  6550.,  7166.,
      7404.,  8636.,  9868.,  11100., 20584., 23176., 25768., 28360., 30952.,
      33544., 36136., 38728., 19132., 20492., 21852., 23212., 22188., 23420.,
      24652., 25884., 51688., 54280., 56872., 59464., 62056., 64648., 67240.,
      69832., 35452., 36812., 38172., 39532., 16750., 17430., 18110., 18790.,
      37796., 39220., 40644., 42068., 43492., 44916., 46340., 47764., 24278.,
      25022., 25766., 26510.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      32.,   68.,   89.,   110.,  96.,   114.,  219.,  264.,  309.,  252.,
      249.,  444.,  489.,  534.,  417.,  320.,  539.,  578.,  617.,  460.,
      272.,  488.,  509.,  530.,  416.,  654.,  1119., 1164., 1209., 912.,
      789.,  1344., 1389., 1434., 1077., 800.,  1319., 1358., 1397., 1020.,
      512.,  908.,  929.,  950.,  736.,  1194., 2019., 2064., 2109., 1572.,
      1329., 2244., 2289., 2334., 1737., 1280., 2099., 2138., 2177., 1580.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   4.,   10.,  12.,  9.,   8.,   26.,  56.,  54.,  36.,  23.,  62.,
      119., 102., 63.,  28.,  67.,  118., 93.,  54.,  7.,   22.,  46.,  42.,
      27.,  38.,  98.,  182., 150., 90.,  89.,  206., 353., 270., 153., 70.,
      157., 262., 195., 108., 13.,  40.,  82.,  72.,  45.,  68.,  170., 308.,
      246., 144., 155., 350., 587., 438., 243., 112., 247., 406., 297., 162.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      204.,   454.,   610.,   766.,   684.,   786.,   1545.,  1887.,  2229.,
      1842.,  1806.,  3255.,  3597.,  3939.,  3102.,  2404.,  4066.,  4366.,
      4666.,  3492.,  1964.,  3574.,  3730.,  3886.,  3084.,  4866.,  8385.,
      8727.,  9069.,  6882.,  5886.,  10095., 10437., 10779., 8142.,  6084.,
      10066., 10366., 10666., 7812.,  3724.,  6694.,  6850.,  7006.,  5484.,
      8946.,  15225., 15567., 15909., 11922., 9966.,  16935., 17277., 17619.,
      13182., 9764.,  16066., 16366., 16666., 12132.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    22.,   59.,   78.,   61.,   46.,  164.,  370.,  372.,  254.,
      154.,  428.,  838.,  732.,  458.,  203., 490.,  869.,  690.,  403.,
      41.,   142.,  311.,  294.,  193.,  262., 692.,  1306., 1092., 662.,
      658.,  1532., 2638., 2028., 1154., 527., 1186., 1985., 1482., 823.,
      77.,   262.,  563.,  510.,  325.,  478., 1220., 2242., 1812., 1070.,
      1162., 2636., 4438., 3324., 1850., 851., 1882., 3101., 2274., 1243.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1432.,   3284.,   4484.,   5684.,   5144.,   5796.,   11550.,  14214.,
      16878.,  14052.,  13716.,  24870.,  27534.,  30198.,  23892.,  18616.,
      31556.,  33908.,  36260.,  27192.,  14872.,  27284.,  28484.,  29684.,
      23704.,  37476.,  64830.,  67494.,  70158.,  53412.,  45396.,  78150.,
      80814.,  83478.,  63252.,  47416.,  78596.,  80948.,  83300.,  61112.,
      28312.,  51284.,  52484.,  53684.,  42264.,  69156.,  118110., 120774.,
      123438., 92772.,  77076.,  131430., 134094., 136758., 102612., 76216.,
      125636., 127988., 130340., 95032.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    140.,   394.,   556.,   446.,   300.,   1144.,  2660.,  2744.,
      1900.,  1116.,  3160.,  6260.,  5528.,  3484.,  1542.,  3740.,  6658.,
      5308.,  3110.,  270.,   1004.,  2266.,  2188.,  1454.,  1932.,  5176.,
      9860.,  8312.,  5068.,  5052.,  11800., 20372., 15704., 8956.,  4086.,
      9212.,  15442., 11548., 6422.,  510.,   1868.,  4138.,  3820.,  2462.,
      3564.,  9208.,  17060., 13880., 8236.,  8988.,  20440., 34484., 25880.,
      14428., 6630.,  14684., 24226., 17788., 9734.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      48.,   64.,   109.,  136.,  145.,  178.,  181.,  220.,  164.,  192.,
      189.,  228.,  375.,  438.,  456.,  528.,  537.,  618.,  447.,  504.,
      429.,  498.,  780.,  888.,  861.,  978.,  942.,  1068., 747.,  834.,
      584.,  640.,  991.,  1078., 1063., 1156., 1135., 1234., 852.,  920.,
      448.,  544.,  829.,  976.,  865.,  1018., 901.,  1060., 724.,  832.,
      1149., 1308., 1995., 2238., 2076., 2328., 2157., 2418., 1647., 1824.,
      1389., 1578., 2400., 2688., 2481., 2778., 2562., 2868., 1947., 2154.,
      1464., 1600., 2431., 2638., 2503., 2716., 2575., 2794., 1892., 2040.,
      848.,  1024., 1549., 1816., 1585., 1858., 1621., 1900., 1284., 1472.,
      2109., 2388., 3615., 4038., 3696., 4128., 3777., 4218., 2847., 3144.,
      2349., 2658., 4020., 4488., 4101., 4578., 4182., 4668., 3147., 3474.,
      2344., 2560., 3871., 4198., 3943., 4276., 4015., 4354., 2932., 3160.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   5.,   8.,   14.,  20.,  19.,  24.,  15.,   18.,   11.,  16.,
      40.,  52.,  91.,  112., 92.,  108., 63.,  72.,  41.,   46.,   112., 124.,
      217., 238., 188., 204., 117., 126., 52.,  56.,  125.,  134.,  221., 236.,
      175., 186., 102., 108., 7.,   14.,  29.,  44.,  68.,   92.,   67.,  84.,
      45.,  54.,  59.,  76.,  160., 196., 307., 364., 260.,  300.,  159., 180.,
      161., 178., 376., 412., 649., 706., 500., 540., 285.,  306.,  130., 140.,
      293., 314., 491., 524., 367., 390., 204., 216., 13.,   26.,   53.,  80.,
      122., 164., 115., 144., 75.,  90.,  107., 136., 280.,  340.,  523., 616.,
      428., 492., 255., 288., 281., 310., 640., 700., 1081., 1174., 812., 876.,
      453., 486., 208., 224., 461., 494., 761., 812., 559.,  594.,  306., 324.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      316.,   436.,   752.,   956.,   1028.,  1280.,  1304.,  1604.,  1204.,
      1420.,  1344.,  1644.,  2721.,  3207.,  3351.,  3909.,  3981.,  4611.,
      3348.,  3792.,  3204.,  3744.,  5871.,  6717.,  6501.,  7419.,  7131.,
      8121.,  5688.,  6372.,  4476.,  4916.,  7616.,  8300.,  8180.,  8912.,
      8744.,  9524.,  6580.,  7116.,  3356.,  4116.,  6272.,  7436.,  6548.,
      7760.,  6824.,  8084.,  5524.,  6380.,  8784.,  10044., 15321., 17247.,
      15951., 17949., 16581., 18651., 12708., 14112., 10644., 12144., 18471.,
      20757., 19101., 21459., 19731., 22161., 15048., 16692., 11356., 12436.,
      18896., 20540., 19460., 21152., 20024., 21764., 14740., 15916., 6396.,
      7796.,  11792., 13916., 12068., 14240., 12344., 14564., 9844.,  11340.,
      16224., 18444., 27921., 31287., 28551., 31989., 29181., 32691., 22068.,
      24432., 18084., 20544., 31071., 34797., 31701., 35499., 32331., 36201.,
      24408., 27012., 18236., 19956., 30176., 32780., 30740., 33392., 31304.,
      34004., 22900., 24716.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    11.,   28.,   48.,   85.,   127.,  128.,  164.,  105.,  127.,
      64.,   100.,  260.,  348.,  620.,  776.,  652.,  772.,  456.,  524.,
      280.,  316.,  788.,  876.,  1556., 1712., 1372., 1492., 864.,  932.,
      383.,  413.,  928.,  996.,  1651., 1765., 1316., 1400., 771.,  817.,
      41.,   95.,   196.,  312.,  481.,  667.,  488.,  620.,  333.,  403.,
      424.,  556.,  1172., 1452., 2276., 2720., 1948., 2260., 1200., 1364.,
      1216., 1348., 2852., 3132., 4940., 5384., 3820., 4132., 2184., 2348.,
      995.,  1073., 2248., 2412., 3775., 4033., 2828., 3008., 1575., 1669.,
      77.,   179.,  364.,  576.,  877.,  1207., 848.,  1076., 561.,  679.,
      784.,  1012., 2084., 2556., 3932., 4664., 3244., 3748., 1944., 2204.,
      2152., 2380., 4916., 5388., 8324., 9056., 6268., 6772., 3504., 3764.,
      1607., 1733., 3568., 3828., 5899., 6301., 4340., 4616., 2379., 2521.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2264.,   3192.,   5548.,   7132.,   7708.,   9676.,   9868.,   12220.,
      9208.,   10904.,  10092.,  12444.,  20670.,  24486.,  25638.,  30030.,
      30606.,  35574.,  25884.,  29388.,  24732.,  29004.,  45510.,  52206.,
      50478.,  57750.,  55446.,  63294.,  44364.,  49788.,  35032.,  38520.,
      59692.,  65116.,  64156.,  69964.,  68620.,  74812.,  51704.,  55960.,
      25944.,  31992.,  48748.,  58012.,  50908.,  60556.,  53068.,  63100.,
      43128.,  49944.,  68652.,  78684.,  120030., 135366., 124998., 140910.,
      129966., 146454., 99804.,  110988., 83292.,  95244.,  144870., 163086.,
      149838., 168630., 154806., 174174., 118284., 131388., 89432.,  98040.,
      148972., 162076., 153436., 166924., 157900., 171772., 116344., 125720.,
      49624.,  60792.,  91948.,  108892., 94108.,  111436., 96268.,  113980.,
      77048.,  88984.,  127212., 144924., 219390., 246246., 224358., 251790.,
      229326., 257334., 173724., 192588., 141852., 161484., 244230., 273966.,
      249198., 279510., 254166., 285054., 192204., 212988., 143832., 157560.,
      238252., 259036., 242716., 263884., 247180., 268732., 180984., 195480.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    70.,    180.,   324.,   578.,   890.,   932.,   1204.,  782.,
      950.,   420.,   692.,   1848.,  2520.,  4540.,  5740.,  4888.,  5816.,
      3460.,  3988.,  2052.,  2324.,  5880.,  6552.,  11740., 12940., 10456.,
      11384., 6628.,  7156.,  2934.,  3166.,  7140.,  7668.,  12746., 13634.,
      10196., 10852., 5990.,  6350.,  270.,   694.,   1428.,  2340.,  3602.,
      5066.,  3716.,  4756.,  2558.,  3110.,  3204.,  4244.,  8952.,  11160.,
      17500., 21004., 15064., 17528., 9316.,  10612., 9444.,  10484., 22200.,
      24408., 38524., 42028., 29848., 32312., 17092., 18388., 7782.,  8398.,
      17604., 18900., 29594., 31634., 22196., 23620., 12374., 13118., 510.,
      1318.,  2676.,  4356.,  6626.,  9242.,  6500.,  8308.,  4334.,  5270.,
      5988.,  7796.,  16056., 19800., 30460., 36268., 25240., 29240., 15172.,
      17236., 16836., 18644., 38520., 42264., 65308., 71116., 49240., 53240.,
      27556., 29620., 12630., 13630., 28068., 30132., 46442., 49634., 34196.,
      36388., 18758., 19886.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      80.,   96.,   112.,  128.,  191.,  218.,  245.,  272.,  257.,  290.,
      323.,  356.,  323.,  362.,  401.,  440.,  300.,  328.,  356.,  384.,
      339.,  378.,  417.,  456.,  687.,  750.,  813.,  876.,  840.,  912.,
      984.,  1056., 993.,  1074., 1155., 1236., 837.,  894.,  951.,  1008.,
      789.,  858.,  927.,  996.,  1452., 1560., 1668., 1776., 1605., 1722.,
      1839., 1956., 1758., 1884., 2010., 2136., 1407., 1494., 1581., 1668.,
      1112., 1168., 1224., 1280., 1895., 1982., 2069., 2156., 2033., 2126.,
      2219., 2312., 2171., 2270., 2369., 2468., 1636., 1704., 1772., 1840.,
      800.,  896.,  992.,  1088., 1511., 1658., 1805., 1952., 1577., 1730.,
      1883., 2036., 1643., 1802., 1961., 2120., 1340., 1448., 1556., 1664.,
      2139., 2298., 2457., 2616., 3747., 3990., 4233., 4476., 3900., 4152.,
      4404., 4656., 4053., 4314., 4575., 4836., 3117., 3294., 3471., 3648.,
      2589., 2778., 2967., 3156., 4512., 4800., 5088., 5376., 4665., 4962.,
      5259., 5556., 4818., 5124., 5430., 5736., 3687., 3894., 4101., 4308.,
      2792., 2928., 3064., 3200., 4655., 4862., 5069., 5276., 4793., 5006.,
      5219., 5432., 4931., 5150., 5369., 5588., 3636., 3784., 3932., 4080.,
      1520., 1696., 1872., 2048., 2831., 3098., 3365., 3632., 2897., 3170.,
      3443., 3716., 2963., 3242., 3521., 3800., 2380., 2568., 2756., 2944.,
      3939., 4218., 4497., 4776., 6807., 7230., 7653., 8076., 6960., 7392.,
      7824., 8256., 7113., 7554., 7995., 8436., 5397., 5694., 5991., 6288.,
      4389., 4698., 5007., 5316., 7572., 8040., 8508., 8976., 7725., 8202.,
      8679., 9156., 7878., 8364., 8850., 9336., 5967., 6294., 6621., 6948.,
      4472., 4688., 4904., 5120., 7415., 7742., 8069., 8396., 7553., 7886.,
      8219., 8552., 7691., 8030., 8369., 8708., 5636., 5864., 6092., 6320.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    2.,    3.,    4.,    7.,    10.,   13.,   16.,   22.,   28.,
      34.,   40.,   33.,   38.,   43.,   48.,   27.,   30.,   33.,   36.,
      17.,   22.,   27.,   32.,   68.,   80.,   92.,   104.,  161.,  182.,
      203.,  224.,  168.,  184.,  200.,  216.,  117.,  126.,  135.,  144.,
      77.,   82.,   87.,   92.,   212.,  224.,  236.,  248.,  413.,  434.,
      455.,  476.,  360.,  376.,  392.,  408.,  225.,  234.,  243.,  252.,
      100.,  104.,  108.,  112.,  241.,  250.,  259.,  268.,  427.,  442.,
      457.,  472.,  339.,  350.,  361.,  372.,  198.,  204.,  210.,  216.,
      7.,    14.,   21.,   28.,   43.,   58.,   73.,   88.,   112.,  136.,
      160.,  184.,  117.,  134.,  151.,  168.,  81.,   90.,   99.,   108.,
      101.,  118.,  135.,  152.,  284.,  320.,  356.,  392.,  557.,  614.,
      671.,  728.,  480.,  520.,  560.,  600.,  297.,  318.,  339.,  360.,
      305.,  322.,  339.,  356.,  716.,  752.,  788.,  824.,  1241., 1298.,
      1355., 1412., 960.,  1000., 1040., 1080., 549.,  570.,  591.,  612.,
      250.,  260.,  270.,  280.,  565.,  586.,  607.,  628.,  949.,  982.,
      1015., 1048., 711.,  734.,  757.,  780.,  396.,  408.,  420.,  432.,
      13.,   26.,   39.,   52.,   79.,   106.,  133.,  160.,  202.,  244.,
      286.,  328.,  201.,  230.,  259.,  288.,  135.,  150.,  165.,  180.,
      185.,  214.,  243.,  272.,  500.,  560.,  620.,  680.,  953.,  1046.,
      1139., 1232., 792.,  856.,  920.,  984.,  477.,  510.,  543.,  576.,
      533.,  562.,  591.,  620.,  1220., 1280., 1340., 1400., 2069., 2162.,
      2255., 2348., 1560., 1624., 1688., 1752., 873.,  906.,  939.,  972.,
      400.,  416.,  432.,  448.,  889.,  922.,  955.,  988.,  1471., 1522.,
      1573., 1624., 1083., 1118., 1153., 1188., 594.,  612.,  630.,  648.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      540.,   660.,   780.,   900.,   1348.,  1552.,  1756.,  1960.,  1864.,
      2116.,  2368.,  2620.,  2380.,  2680.,  2980.,  3280.,  2244.,  2460.,
      2676.,  2892.,  2460.,  2760.,  3060.,  3360.,  5073.,  5559.,  6045.,
      6531.,  6279.,  6837.,  7395.,  7953.,  7485.,  8115.,  8745.,  9375.,
      6360.,  6804.,  7248.,  7692.,  6000.,  6540.,  7080.,  7620.,  11103.,
      11949., 12795., 13641., 12309., 13227., 14145., 15063., 13515., 14505.,
      15495., 16485., 10860., 11544., 12228., 12912., 8620.,  9060.,  9500.,
      9940.,  14716., 15400., 16084., 16768., 15808., 16540., 17272., 18004.,
      16900., 17680., 18460., 19240., 12756., 13292., 13828., 14364., 6140.,
      6900.,  7660.,  8420.,  11668., 12832., 13996., 15160., 12184., 13396.,
      14608., 15820., 12700., 13960., 15220., 16480., 10404., 11260., 12116.,
      12972., 16620., 17880., 19140., 20400., 29193., 31119., 33045., 34971.,
      30399., 32397., 34395., 36393., 31605., 33675., 35745., 37815., 24360.,
      25764., 27168., 28572., 20160., 21660., 23160., 24660., 35223., 37509.,
      39795., 42081., 36429., 38787., 41145., 43503., 37635., 40065., 42495.,
      44925., 28860., 30504., 32148., 33792., 21900., 22980., 24060., 25140.,
      36556., 38200., 39844., 41488., 37648., 39340., 41032., 42724., 38740.,
      40480., 42220., 43960., 28596., 29772., 30948., 32124., 11740., 13140.,
      14540., 15940., 21988., 24112., 26236., 28360., 22504., 24676., 26848.,
      29020., 23020., 25240., 27460., 29680., 18564., 20060., 21556., 23052.,
      30780., 33000., 35220., 37440., 53313., 56679., 60045., 63411., 54519.,
      57957., 61395., 64833., 55725., 59235., 62745., 66255., 42360., 44724.,
      47088., 49452., 34320., 36780., 39240., 41700., 59343., 63069., 66795.,
      70521., 60549., 64347., 68145., 71943., 61755., 65625., 69495., 73365.,
      46860., 49464., 52068., 54672., 35180., 36900., 38620., 40340., 58396.,
      61000., 63604., 66208., 59488., 62140., 64792., 67444., 60580., 63280.,
      65980., 68680., 44436., 46252., 48068., 49884.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,     11.,    17.,    23.,    40.,    60.,    80.,    100.,   137.,
      179.,   221.,   263.,   228.,   264.,   300.,   336.,   193.,   215.,
      237.,   259.,   100.,   136.,   172.,   208.,   452.,   540.,   628.,
      716.,   1120.,  1276.,  1432.,  1588.,  1212.,  1332.,  1452.,  1572.,
      860.,   928.,   996.,   1064.,  532.,   568.,   604.,   640.,   1508.,
      1596.,  1684.,  1772.,  2992.,  3148.,  3304.,  3460.,  2652.,  2772.,
      2892.,  3012.,  1676.,  1744.,  1812.,  1880.,  743.,   773.,   803.,
      833.,   1804.,  1872.,  1940.,  2008.,  3215.,  3329.,  3443.,  3557.,
      2568.,  2652.,  2736.,  2820.,  1507.,  1553.,  1599.,  1645.,  41.,
      95.,    149.,   203.,   304.,   420.,   536.,   652.,   821.,   1007.,
      1193.,  1379.,  876.,   1008.,  1140.,  1272.,  613.,   683.,   753.,
      823.,   748.,   880.,   1012.,  1144.,  2132.,  2412.,  2692.,  2972.,
      4216.,  4660.,  5104.,  5548.,  3660.,  3972.,  4284.,  4596.,  2276.,
      2440.,  2604.,  2768.,  2332.,  2464.,  2596.,  2728.,  5492.,  5772.,
      6052.,  6332.,  9544.,  9988.,  10432., 10876., 7404.,  7716.,  8028.,
      8340.,  4244.,  4408.,  4572.,  4736.,  1931.,  2009.,  2087.,  2165.,
      4372.,  4536.,  4700.,  4864.,  7355.,  7613.,  7871.,  8129.,  5520.,
      5700.,  5880.,  6060.,  3079.,  3173.,  3267.,  3361.,  77.,    179.,
      281.,   383.,   568.,   780.,   992.,   1204.,  1505.,  1835.,  2165.,
      2495.,  1524.,  1752.,  1980.,  2208.,  1033.,  1151.,  1269.,  1387.,
      1396.,  1624.,  1852.,  2080.,  3812.,  4284.,  4756.,  5228.,  7312.,
      8044.,  8776.,  9508.,  6108.,  6612.,  7116.,  7620.,  3692.,  3952.,
      4212.,  4472.,  4132.,  4360.,  4588.,  4816.,  9476.,  9948.,  10420.,
      10892., 16096., 16828., 17560., 18292., 12156., 12660., 13164., 13668.,
      6812.,  7072.,  7332.,  7592.,  3119.,  3245.,  3371.,  3497.,  6940.,
      7200.,  7460.,  7720.,  11495., 11897., 12299., 12701., 8472.,  8748.,
      9024.,  9300.,  4651.,  4793.,  4935.,  5077.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3928.,   4856.,   5784.,   6712.,   10076.,  11660.,  13244.,  14828.,
      14156.,  16124.,  18092.,  20060.,  18236.,  20588.,  22940.,  25292.,
      17336.,  19032.,  20728.,  22424.,  18684.,  21036.,  23388.,  25740.,
      38910.,  42726.,  46542.,  50358.,  48486.,  52878.,  57270.,  61662.,
      58062.,  63030.,  67998.,  72966.,  49548.,  53052.,  56556.,  60060.,
      46764.,  51036.,  55308.,  59580.,  86790.,  93486.,  100182., 106878.,
      96366.,  103638., 110910., 118182., 105942., 113790., 121638., 129486.,
      85308.,  90732.,  96156.,  101580., 67864.,  71352.,  74840.,  78328.,
      115964., 121388., 126812., 132236., 124652., 130460., 136268., 142076.,
      133340., 139532., 145724., 151916., 100728., 104984., 109240., 113496.,
      48088.,  54136.,  60184.,  66232.,  91676.,  100940., 110204., 119468.,
      95756.,  105404., 115052., 124700., 99836.,  109868., 119900., 129932.,
      81976.,  88792.,  95608.,  102424., 131004., 141036., 151068., 161100.,
      230430., 245766., 261102., 276438., 240006., 255918., 271830., 287742.,
      249582., 266070., 282558., 299046., 192588., 203772., 214956., 226140.,
      159084., 171036., 182988., 194940., 278310., 296526., 314742., 332958.,
      287886., 306678., 325470., 344262., 297462., 316830., 336198., 355566.,
      228348., 241452., 254556., 267660., 173464., 182072., 190680., 199288.,
      289724., 302828., 315932., 329036., 298412., 311900., 325388., 338876.,
      307100., 320972., 334844., 348716., 226808., 236184., 245560., 254936.,
      92248.,  103416., 114584., 125752., 173276., 190220., 207164., 224108.,
      177356., 194684., 212012., 229340., 181436., 199148., 216860., 234572.,
      146616., 158552., 170488., 182424., 243324., 261036., 278748., 296460.,
      421950., 448806., 475662., 502518., 431526., 458958., 486390., 513822.,
      441102., 469110., 497118., 525126., 335628., 354492., 373356., 392220.,
      271404., 291036., 310668., 330300., 469830., 499566., 529302., 559038.,
      479406., 509718., 540030., 570342., 488982., 519870., 550758., 581646.,
      371388., 392172., 412956., 433740., 279064., 292792., 306520., 320248.,
      463484., 484268., 505052., 525836., 472172., 493340., 514508., 535676.,
      480860., 502412., 523964., 545516., 352888., 367384., 381880., 396376.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,     70.,     110.,    150.,    260.,   404.,   548.,    692.,
      946.,    1258.,   1570.,   1882.,   1684.,  1956.,  2228.,   2500.,
      1454.,   1622.,   1790.,   1958.,   660.,   932.,   1204.,   1476.,
      3256.,   3928.,   4600.,   5272.,   8300.,  9500.,  10700.,  11900.,
      9176.,   10104.,  11032.,  11960.,  6580.,  7108.,  7636.,   8164.,
      3924.,   4196.,   4468.,   4740.,   11320., 11992., 12664.,  13336.,
      22700.,  23900.,  25100.,  26300.,  20312., 21240., 22168.,  23096.,
      12916.,  13444.,  13972.,  14500.,  5718.,  5950.,  6182.,   6414.,
      13940.,  14468.,  14996.,  15524.,  24922., 25810., 26698.,  27586.,
      19972.,  20628.,  21284.,  21940.,  11750., 12110., 12470.,  12830.,
      270.,    694.,    1118.,   1542.,   2276.,  3188.,  4100.,   5012.,
      6274.,   7738.,   9202.,   10666.,  6772.,  7812.,  8852.,   9892.,
      4766.,   5318.,   5870.,   6422.,   5748.,  6788.,  7828.,   8868.,
      16504.,  18712.,  20920.,  23128.,  32780., 36284., 39788.,  43292.,
      28568.,  31032.,  33496.,  35960.,  17812., 19108., 20404.,  21700.,
      18228.,  19268.,  20308.,  21348.,  43000., 45208., 47416.,  49624.,
      74828.,  78332.,  81836.,  85340.,  58136., 60600., 63064.,  65528.,
      33364.,  34660.,  35956.,  37252.,  15174., 15790., 16406.,  17022.,
      34388.,  35684.,  36980.,  38276.,  57898., 59938., 61978.,  64018.,
      43492.,  44916.,  46340.,  47764.,  24278., 25022., 25766.,  26510.,
      510.,    1318.,   2126.,   2934.,   4292.,  5972.,  7652.,   9332.,
      11602.,  14218.,  16834.,  19450.,  11860., 13668., 15476.,  17284.,
      8078.,   9014.,   9950.,   10886.,  10836., 12644., 14452.,  16260.,
      29752.,  33496.,  37240.,  40984.,  57260., 63068., 68876.,  74684.,
      47960.,  51960.,  55960.,  59960.,  29044., 31108., 33172.,  35236.,
      32532.,  34340.,  36148.,  37956.,  74680., 78424., 82168.,  85912.,
      126956., 132764., 138572., 144380., 95960., 99960., 103960., 107960.,
      53812.,  55876.,  57940.,  60004.,  24630., 25630., 26630.,  27630.,
      54836.,  56900.,  58964.,  61028.,  90874., 94066., 97258.,  100450.,
      67012.,  69204.,  71396.,  73588.,  36806., 37934., 39062.,  40190.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      35.,   74.,   95.,   116.,  137.,  117.,  129.,  246.,  291.,
      336.,  381.,  306.,  291.,  516.,  561.,  606.,  651.,  504.,
      377.,  632.,  671.,  710.,  749.,  555.,  323.,  578.,  599.,
      620.,  641.,  501.,  777.,  1326., 1371., 1416., 1461., 1098.,
      939.,  1596., 1641., 1686., 1731., 1296., 953.,  1568., 1607.,
      1646., 1685., 1227., 611.,  1082., 1103., 1124., 1145., 885.,
      1425., 2406., 2451., 2496., 2541., 1890., 1587., 2676., 2721.,
      2766., 2811., 2088., 1529., 2504., 2543., 2582., 2621., 1899.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   4.,   10.,  16.,  17.,  12.,  9.,   29.,  62.,  83.,  75.,  48.,
      27.,  71.,  134., 173., 141., 84.,  35.,  82.,  142., 166., 127., 72.,
      9.,   28.,  58.,  64.,  57.,  36.,  49.,  125., 230., 251., 203., 120.,
      115., 263., 446., 485., 365., 204., 91.,  202., 334., 358., 263., 144.,
      17.,  52.,  106., 112., 97.,  60.,  89.,  221., 398., 419., 331., 192.,
      203., 455., 758., 797., 589., 324., 147., 322., 526., 550., 399., 216.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      224.,   496.,   652.,   808.,   964.,   840.,   894.,   1743.,  2085.,
      2427.,  2769.,  2250.,  2118.,  3795.,  4137.,  4479.,  4821.,  3762.,
      2840.,  4780.,  5080.,  5380.,  5680.,  4224.,  2336.,  4240.,  4396.,
      4552.,  4708.,  3720.,  5790.,  9951.,  10293., 10635., 10977., 8298.,
      7014.,  12003., 12345., 12687., 13029., 9810.,  7256.,  11980., 12280.,
      12580., 12880., 9408.,  4448.,  7984.,  8140.,  8296.,  8452.,  6600.,
      10686., 18159., 18501., 18843., 19185., 14346., 11910., 20211., 20553.,
      20895., 21237., 15858., 11672., 19180., 19480., 19780., 20080., 14592.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    22.,   59.,   101.,  114.,  83.,   52.,   184.,  412.,
      568.,  528.,  344.,  184.,  496.,  952.,  1252., 1032., 620.,
      257.,  606.,  1055., 1241., 954.,  543.,  53.,   182.,  395.,
      437.,  402.,  259.,  340.,  888.,  1660., 1816., 1488., 888.,
      856.,  1968., 3352., 3652., 2760., 1548., 689.,  1534., 2543.,
      2729., 2010., 1103., 101.,  342.,  731.,  773.,  690.,  435.,
      628.,  1592., 2908., 3064., 2448., 1432., 1528., 3440., 5752.,
      6052., 4488., 2476., 1121., 2462., 4031., 4217., 3066., 1663.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1576.,   3596.,   4796.,   5996.,   7196.,   6344.,   6612.,   13062.,
      15726.,  18390.,  21054.,  17220.,  16116.,  29046.,  31710.,  34374.,
      37038.,  29028.,  22024.,  37148.,  39500.,  41852.,  44204.,  32936.,
      17704.,  32396.,  33596.,  34796.,  35996.,  28616.,  44628.,  76998.,
      79662.,  82326.,  84990.,  64452.,  54132.,  92982.,  95646.,  98310.,
      100974., 76260.,  56584.,  93596.,  95948.,  98300.,  100652., 73640.,
      33832.,  61196.,  62396.,  63596.,  64796.,  50888.,  82644.,  140934.,
      143598., 146262., 148926., 111684., 92148.,  156918., 159582., 162246.,
      164910., 123492., 91144.,  150044., 152396., 154748., 157100., 114344.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    140.,   394.,   706.,   828.,   614.,   340.,   1288.,  2972.,
      4172.,  3944.,  2596.,  1348.,  3688.,  7148.,  9500.,  7880.,  4756.,
      1966.,  4652.,  8122.,  9586.,  7388.,  4214.,  350.,   1292.,  2890.,
      3202.,  3004.,  1958.,  2516.,  6664.,  12572., 13772., 11368., 6820.,
      6596.,  15208., 25964., 28316., 21448., 12052., 5358.,  11948., 19834.,
      21298., 15708., 8630.,  670.,   2444.,  5386.,  5698.,  5180.,  3302.,
      4692.,  12040., 22172., 23372., 18792., 11044., 11844., 26728., 44780.,
      47132., 35016., 19348., 8750.,  19244., 31546., 33010., 24028., 13046.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      52.,   70.,   118.,  148.,  154.,  190.,  190.,  232.,  226.,  274.,
      200.,  234.,  213.,  258.,  420.,  492.,  501.,  582.,  582.,  672.,
      663.,  762.,  543.,  612.,  501.,  582.,  906.,  1032., 987.,  1122.,
      1068., 1212., 1149., 1302., 903.,  1008., 688.,  754.,  1162., 1264.,
      1234., 1342., 1306., 1420., 1378., 1498., 1028., 1110., 532.,  646.,
      982.,  1156., 1018., 1198., 1054., 1240., 1090., 1282., 872.,  1002.,
      1365., 1554., 2364., 2652., 2445., 2742., 2526., 2832., 2607., 2922.,
      1983., 2196., 1653., 1878., 2850., 3192., 2931., 3282., 3012., 3372.,
      3093., 3462., 2343., 2592., 1744., 1906., 2890., 3136., 2962., 3214.,
      3034., 3292., 3106., 3370., 2276., 2454., 1012., 1222., 1846., 2164.,
      1882., 2206., 1918., 2248., 1954., 2290., 1544., 1770., 2517., 2850.,
      4308., 4812., 4389., 4902., 4470., 4992., 4551., 5082., 3423., 3780.,
      2805., 3174., 4794., 5352., 4875., 5442., 4956., 5532., 5037., 5622.,
      3783., 4176., 2800., 3058., 4618., 5008., 4690., 5086., 4762., 5164.,
      4834., 5242., 3524., 3798.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   5.,   8.,    14.,   20.,   23.,   32.,   27.,   34.,  20.,
      24.,  12.,  18.,  44.,   58.,   100.,  124.,  136.,  166.,  128., 150.,
      84.,  96.,  48.,  54.,   128.,  142.,  244.,  268.,  316.,  346., 260.,
      282., 156., 168., 65.,   70.,   153.,  164.,  266.,  284.,  311., 332.,
      239., 254., 136., 144.,  9.,    18.,   37.,   56.,   86.,   116., 95.,
      128., 91.,  114., 60.,   72.,   76.,   98.,   204.,  250.,  388., 460.,
      424., 502., 352., 406.,  212.,  240.,  208.,  230.,  480.,  526., 820.,
      892., 892., 970., 676.,  730.,  380.,  408.,  169.,  182.,  377., 404.,
      626., 668., 671., 716.,  495.,  526.,  272.,  288.,  17.,   34.,  69.,
      104., 158., 212., 167.,  224.,  155.,  194.,  100.,  120.,  140., 178.,
      364., 442., 676., 796.,  712.,  838.,  576.,  662.,  340.,  384., 368.,
      406., 832., 910., 1396., 1516., 1468., 1594., 1092., 1178., 604., 648.,
      273., 294., 601., 644.,  986.,  1052., 1031., 1100., 751.,  798., 408.,
      432.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      344.,   480.,   818.,   1046.,  1094.,  1370.,  1370.,  1694.,  1646.,
      2018.,  1480.,  1744.,  1524.,  1872.,  3063.,  3621.,  3693.,  4323.,
      4323.,  5025.,  4953.,  5727.,  4092.,  4632.,  3756.,  4392.,  6843.,
      7833.,  7473.,  8535.,  8103.,  9237.,  8733.,  9939.,  6900.,  7728.,
      5288.,  5808.,  8954.,  9758.,  9518.,  10370., 10082., 10982., 10646.,
      11594., 7960.,  8608.,  3992.,  4896.,  7442.,  8822.,  7718.,  9146.,
      7994.,  9470.,  8270.,  9794.,  6664.,  7696.,  10452., 11952., 18183.,
      20469., 18813., 21171., 19443., 21873., 20073., 22575., 15324., 17016.,
      12684., 14472., 21963., 24681., 22593., 25383., 23223., 26085., 23853.,
      26787., 18132., 20112., 13544., 14832., 22490., 24446., 23054., 25058.,
      23618., 25670., 24182., 26282., 17752., 19168., 7640.,  9312.,  14066.,
      16598., 14342., 16922., 14618., 17246., 14894., 17570., 11848., 13648.,
      19380., 22032., 33303., 37317., 33933., 38019., 34563., 38721., 35193.,
      39423., 26556., 29400., 21612., 24552., 37083., 41529., 37713., 42231.,
      38343., 42933., 38973., 43635., 29364., 32496., 21800., 23856., 36026.,
      39134., 36590., 39746., 37154., 40358., 37718., 40970., 27544., 29728.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    11.,   28.,   48.,   85.,    127.,   151.,   217.,   188.,  240.,
      143.,  173.,  70.,   114.,  288.,   392.,   686.,   866.,   962.,  1190.,
      928.,  1096., 618.,  710.,  334.,   378.,   912.,   1016.,  1766., 1946.,
      2330., 2558., 1936., 2104., 1170.,  1262.,  485.,   523.,   1148., 1232.,
      2005., 2143., 2359., 2521., 1820.,  1936.,  1039.,  1101.,  53.,   123.,
      252.,  400.,  613.,  847.,  679.,   937.,   668.,   848.,   447.,  541.,
      550.,  722.,  1504., 1864., 2894.,  3458.,  3170.,  3782.,  2656., 3080.,
      1610., 1830., 1582., 1754., 3664.,  4024.,  6278.,  6842.,  6842., 7454.,
      5200., 5624., 2930., 3150., 1301.,  1403.,  2908.,  3120.,  4837., 5167.,
      5191., 5545., 3836., 4080., 2111.,  2237.,  101.,   235.,   476.,  752.,
      1141., 1567., 1207., 1657., 1148.,  1456.,  751.,   909.,   1030., 1330.,
      2720., 3336., 5102., 6050., 5378.,  6374.,  4384.,  5064.,  2602., 2950.,
      2830., 3130., 6416., 7032., 10790., 11738., 11354., 12350., 8464., 9144.,
      4690., 5038., 2117., 2283., 4668.,  5008.,  7669.,  8191.,  8023., 8569.,
      5852., 6224., 3183., 3373.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2472.,   3528.,   6052.,   7828.,   8212.,   10372.,  10372.,  12916.,
      12532.,  15460.,  11368.,  13448.,  11484.,  14220.,  23334.,  27726.,
      28302.,  33270.,  33270.,  38814.,  38238.,  44358.,  31740.,  36012.,
      29052.,  34092.,  53142.,  60990.,  58110.,  66534.,  63078.,  72078.,
      68046.,  77622.,  53916.,  60492.,  41448.,  45576.,  70276.,  76660.,
      74740.,  81508.,  79204.,  86356.,  83668.,  91204.,  62632.,  67784.,
      30888.,  38088.,  57892.,  68884.,  60052.,  71428.,  62212.,  73972.,
      64372.,  76516.,  52072.,  60296.,  81756.,  93708.,  142566., 160782.,
      147534., 166326., 152502., 171870., 157470., 177414., 120444., 133932.,
      99324.,  113580., 172374., 194046., 177342., 199590., 182310., 205134.,
      187278., 210678., 142620., 158412., 106728., 117000., 177412., 193012.,
      181876., 197860., 186340., 202708., 190804., 207556., 140200., 151496.,
      59304.,  72648.,  109732., 129940., 111892., 132484., 114052., 135028.,
      116212., 137572., 92776.,  107144., 152028., 173196., 261798., 293838.,
      266766., 299382., 271734., 304926., 276702., 310470., 209148., 231852.,
      169596., 193068., 291606., 327102., 296574., 332646., 301542., 338190.,
      306510., 343734., 231324., 256332., 172008., 188424., 284548., 309364.,
      289012., 314212., 293476., 319060., 297940., 323908., 217768., 235208.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    70.,    180.,   324.,   578.,   890.,   1082.,  1586.,  1396.,
      1796.,  1078.,  1310.,  460.,   796.,   2056.,  2856.,  5044.,  6436.,
      7204.,  8980.,  7048.,  8360.,  4732.,  5452.,  2476.,  2812.,  6856.,
      7656.,  13396., 14788., 17860., 19636., 14920., 16232., 9052.,  9772.,
      3742.,  4038.,  8884.,  9540.,  15554., 16634., 18362., 19634., 14196.,
      15108., 8118.,  8606.,  350.,   902.,   1844.,  3012.,  4610.,  6458.,
      5114.,  7154.,  5108.,  6532.,  3446.,  4190.,  4172.,  5532.,  11528.,
      14376., 22324., 26788., 24484., 29332., 20616., 23976., 12540., 14284.,
      12332., 13692., 28616., 31464., 49108., 53572., 53572., 58420., 40776.,
      44136., 23004., 24748., 10206., 11014., 22836., 24516., 38018., 40634.,
      40826., 43634., 30196., 32132., 16630., 17630., 670.,   1734.,  3508.,
      5700.,  8642.,  12026., 9146.,  12722., 8820.,  11268., 5814.,  7070.,
      7884.,  10268., 21000., 25896., 39604., 47140., 41764., 49684., 34184.,
      39592., 20348., 23116., 22188., 24572., 50376., 55272., 84820., 92356.,
      89284., 97204., 66632., 72040., 36956., 39724., 16670., 17990., 36788.,
      39492., 60482., 64634., 63290., 67634., 46196., 49156., 25142., 26654.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      86.,    104.,   122.,   140.,   206.,   236.,   266.,   296.,   272.,
      308.,   344.,   380.,   338.,   380.,   422.,   464.,   404.,   452.,
      500.,   548.,   366.,   400.,   434.,   468.,   381.,   426.,   471.,
      516.,   768.,   840.,   912.,   984.,   921.,   1002.,  1083.,  1164.,
      1074.,  1164.,  1254.,  1344.,  1227.,  1326.,  1425.,  1524.,  1017.,
      1086.,  1155.,  1224.,  921.,   1002.,  1083.,  1164.,  1686.,  1812.,
      1938.,  2064.,  1839.,  1974.,  2109.,  2244.,  1992.,  2136.,  2280.,
      2424.,  2145.,  2298.,  2451.,  2604.,  1701.,  1806.,  1911.,  2016.,
      1310.,  1376.,  1442.,  1508.,  2222.,  2324.,  2426.,  2528.,  2360.,
      2468.,  2576.,  2684.,  2498.,  2612.,  2726.,  2840.,  2636.,  2756.,
      2876.,  2996.,  1974.,  2056.,  2138.,  2220.,  950.,   1064.,  1178.,
      1292.,  1790.,  1964.,  2138.,  2312.,  1856.,  2036.,  2216.,  2396.,
      1922.,  2108.,  2294.,  2480.,  1988.,  2180.,  2372.,  2564.,  1614.,
      1744.,  1874.,  2004.,  2541.,  2730.,  2919.,  3108.,  4440.,  4728.,
      5016.,  5304.,  4593.,  4890.,  5187.,  5484.,  4746.,  5052.,  5358.,
      5664.,  4899.,  5214.,  5529.,  5844.,  3753.,  3966.,  4179.,  4392.,
      3081.,  3306.,  3531.,  3756.,  5358.,  5700.,  6042.,  6384.,  5511.,
      5862.,  6213.,  6564.,  5664.,  6024.,  6384.,  6744.,  5817.,  6186.,
      6555.,  6924.,  4437.,  4686.,  4935.,  5184.,  3326.,  3488.,  3650.,
      3812.,  5534.,  5780.,  6026.,  6272.,  5672.,  5924.,  6176.,  6428.,
      5810.,  6068.,  6326.,  6584.,  5948.,  6212.,  6476.,  6740.,  4374.,
      4552.,  4730.,  4908.,  1814.,  2024.,  2234.,  2444.,  3374.,  3692.,
      4010.,  4328.,  3440.,  3764.,  4088.,  4412.,  3506.,  3836.,  4166.,
      4496.,  3572.,  3908.,  4244.,  4580.,  2862.,  3088.,  3314.,  3540.,
      4701.,  5034.,  5367.,  5700.,  8112.,  8616.,  9120.,  9624.,  8265.,
      8778.,  9291.,  9804.,  8418.,  8940.,  9462.,  9984.,  8571.,  9102.,
      9633.,  10164., 6489.,  6846.,  7203.,  7560.,  5241.,  5610.,  5979.,
      6348.,  9030.,  9588.,  10146., 10704., 9183.,  9750.,  10317., 10884.,
      9336.,  9912.,  10488., 11064., 9489.,  10074., 10659., 11244., 7173.,
      7566.,  7959.,  8352.,  5342.,  5600.,  5858.,  6116.,  8846.,  9236.,
      9626.,  10016., 8984.,  9380.,  9776.,  10172., 9122.,  9524.,  9926.,
      10328., 9260.,  9668.,  10076., 10484., 6774.,  7048.,  7322.,  7596.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    2.,    3.,    4.,    7.,    10.,   13.,   16.,   22.,   28.,
      34.,   40.,   37.,   46.,   55.,   64.,   47.,   54.,   61.,   68.,
      36.,   40.,   44.,   48.,   18.,   24.,   30.,   36.,   74.,   88.,
      102.,  116.,  176.,  200.,  224.,  248.,  242.,  272.,  302.,  332.,
      234.,  256.,  278.,  300.,  156.,  168.,  180.,  192.,  90.,   96.,
      102.,  108.,  242.,  256.,  270.,  284.,  464.,  488.,  512.,  536.,
      602.,  632.,  662.,  692.,  498.,  520.,  542.,  564.,  300.,  312.,
      324.,  336.,  125.,  130.,  135.,  140.,  295.,  306.,  317.,  328.,
      514.,  532.,  550.,  568.,  601.,  622.,  643.,  664.,  463.,  478.,
      493.,  508.,  264.,  272.,  280.,  288.,  9.,    18.,   27.,   36.,
      55.,   74.,   93.,   112.,  142.,  172.,  202.,  232.,  157.,  190.,
      223.,  256.,  159.,  182.,  205.,  228.,  108.,  120.,  132.,  144.,
      130.,  152.,  174.,  196.,  362.,  408.,  454.,  500.,  704.,  776.,
      848.,  920.,  770.,  848.,  926.,  1004., 650.,  704.,  758.,  812.,
      396.,  424.,  452.,  480.,  394.,  416.,  438.,  460.,  914.,  960.,
      1006., 1052., 1568., 1640., 1712., 1784., 1706., 1784., 1862., 1940.,
      1298., 1352., 1406., 1460., 732.,  760.,  788.,  816.,  325.,  338.,
      351.,  364.,  727.,  754.,  781.,  808.,  1210., 1252., 1294., 1336.,
      1297., 1342., 1387., 1432., 959.,  990.,  1021., 1052., 528.,  544.,
      560.,  576.,  17.,   34.,   51.,   68.,   103.,  138.,  173.,  208.,
      262.,  316.,  370.,  424.,  277.,  334.,  391.,  448.,  271.,  310.,
      349.,  388.,  180.,  200.,  220.,  240.,  242.,  280.,  318.,  356.,
      650.,  728.,  806.,  884.,  1232., 1352., 1472., 1592., 1298., 1424.,
      1550., 1676., 1066., 1152., 1238., 1324., 636.,  680.,  724.,  768.,
      698.,  736.,  774.,  812.,  1586., 1664., 1742., 1820., 2672., 2792.,
      2912., 3032., 2810., 2936., 3062., 3188., 2098., 2184., 2270., 2356.,
      1164., 1208., 1252., 1296., 525.,  546.,  567.,  588.,  1159., 1202.,
      1245., 1288., 1906., 1972., 2038., 2104., 1993., 2062., 2131., 2200.,
      1455., 1502., 1549., 1596., 792.,  816.,  840.,  864.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      584.,   720.,   856.,   992.,   1462.,  1690.,  1918.,  2146.,  1978.,
      2254.,  2530.,  2806.,  2494.,  2818.,  3142.,  3466.,  3010.,  3382.,
      3754.,  4126.,  2760.,  3024.,  3288.,  3552.,  2784.,  3132.,  3480.,
      3828.,  5703.,  6261.,  6819.,  7377.,  6909.,  7539.,  8169.,  8799.,
      8115.,  8817.,  9519.,  10221., 9321.,  10095., 10869., 11643., 7776.,
      8316.,  8856.,  9396.,  7032.,  7668.,  8304.,  8940.,  12939., 13929.,
      14919., 15909., 14145., 15207., 16269., 17331., 15351., 16485., 17619.,
      18753., 16557., 17763., 18969., 20175., 13176., 14004., 14832., 15660.,
      10184., 10704., 11224., 11744., 17302., 18106., 18910., 19714., 18394.,
      19246., 20098., 20950., 19486., 20386., 21286., 22186., 20578., 21526.,
      22474., 23422., 15432., 16080., 16728., 17376., 7304.,  8208.,  9112.,
      10016., 13846., 15226., 16606., 17986., 14362., 15790., 17218., 18646.,
      14878., 16354., 17830., 19306., 15394., 16918., 18442., 19966., 12552.,
      13584., 14616., 15648., 19776., 21276., 22776., 24276., 34647., 36933.,
      39219., 41505., 35853., 38211., 40569., 42927., 37059., 39489., 41919.,
      44349., 38265., 40767., 43269., 45771., 29376., 31068., 32760., 34452.,
      24024., 25812., 27600., 29388., 41883., 44601., 47319., 50037., 43089.,
      45879., 48669., 51459., 44295., 47157., 50019., 52881., 45501., 48435.,
      51369., 54303., 34776., 36756., 38736., 40716., 26120., 27408., 28696.,
      29984., 43510., 45466., 47422., 49378., 44602., 46606., 48610., 50614.,
      45694., 47746., 49798., 51850., 46786., 48886., 50986., 53086., 34440.,
      35856., 37272., 38688., 14024., 15696., 17368., 19040., 26230., 28762.,
      31294., 33826., 26746., 29326., 31906., 34486., 27262., 29890., 32518.,
      35146., 27778., 30454., 33130., 35806., 22344., 24144., 25944., 27744.,
      36768., 39420., 42072., 44724., 63591., 67605., 71619., 75633., 64797.,
      68883., 72969., 77055., 66003., 70161., 74319., 78477., 67209., 71439.,
      75669., 79899., 50976., 53820., 56664., 59508., 41016., 43956., 46896.,
      49836., 70827., 75273., 79719., 84165., 72033., 76551., 81069., 85587.,
      73239., 77829., 82419., 87009., 74445., 79107., 83769., 88431., 56376.,
      59508., 62640., 65772., 42056., 44112., 46168., 48224., 69718., 72826.,
      75934., 79042., 70810., 73966., 77122., 80278., 71902., 75106., 78310.,
      81514., 72994., 76246., 79498., 82750., 53448., 55632., 57816., 60000.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,     11.,    17.,    23.,    40.,    60.,    80.,    100.,   137.,
      179.,   221.,   263.,   251.,   317.,   383.,   449.,   336.,   388.,
      440.,   492.,   263.,   293.,   323.,   353.,   106.,   150.,   194.,
      238.,   496.,   600.,   704.,   808.,   1234.,  1414.,  1594.,  1774.,
      1750.,  1978.,  2206.,  2434.,  1728.,  1896.,  2064.,  2232.,  1166.,
      1258.,  1350.,  1442.,  634.,   678.,   722.,   766.,   1744.,  1848.,
      1952.,  2056.,  3394.,  3574.,  3754.,  3934.,  4486.,  4714.,  4942.,
      5170.,  3744.,  3912.,  4080.,  4248.,  2270.,  2362.,  2454.,  2546.,
      941.,   979.,   1017.,  1055.,  2232.,  2316.,  2400.,  2484.,  3905.,
      4043.,  4181.,  4319.,  4595.,  4757.,  4919.,  5081.,  3552.,  3668.,
      3784.,  3900.,  2031.,  2093.,  2155.,  2217.,  53.,    123.,   193.,
      263.,   392.,   540.,   688.,   836.,   1049.,  1283.,  1517.,  1751.,
      1163.,  1421.,  1679.,  1937.,  1200.,  1380.,  1560.,  1740.,  823.,
      917.,   1011.,  1105.,  970.,   1142.,  1314.,  1486.,  2736.,  3096.,
      3456.,  3816.,  5362.,  5926.,  6490.,  7054.,  5878.,  6490.,  7102.,
      7714.,  4992.,  5416.,  5840.,  6264.,  3054.,  3274.,  3494.,  3714.,
      3034.,  3206.,  3378.,  3550.,  7056.,  7416.,  7776.,  8136.,  12130.,
      12694., 13258., 13822., 13222., 13834., 14446., 15058., 10080., 10504.,
      10928., 11352., 5694.,  5914.,  6134.,  6354.,  2525.,  2627.,  2729.,
      2831.,  5656.,  5868.,  6080.,  6292.,  9425.,  9755.,  10085., 10415.,
      10115., 10469., 10823., 11177., 7488.,  7732.,  7976.,  8220.,  4127.,
      4253.,  4379.,  4505.,  101.,   235.,   369.,   503.,   744.,   1020.,
      1296.,  1572.,  1961.,  2387.,  2813.,  3239.,  2075.,  2525.,  2975.,
      3425.,  2064.,  2372.,  2680.,  2988.,  1383.,  1541.,  1699.,  1857.,
      1834.,  2134.,  2434.,  2734.,  4976.,  5592.,  6208.,  6824.,  9490.,
      10438., 11386., 12334., 10006., 11002., 11998., 12994., 8256.,  8936.,
      9616.,  10296., 4942.,  5290.,  5638.,  5986.,  5434.,  5734.,  6034.,
      6334.,  12368., 12984., 13600., 14216., 20866., 21814., 22762., 23710.,
      21958., 22954., 23950., 24946., 16416., 17096., 17776., 18456., 9118.,
      9466.,  9814.,  10162., 4109.,  4275.,  4441.,  4607.,  9080.,  9420.,
      9760.,  10100., 14945., 15467., 15989., 16511., 15635., 16181., 16727.,
      17273., 11424., 11796., 12168., 12540., 6223.,  6413.,  6603.,  6793.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4264.,   5320.,   6376.,   7432.,   10964.,  12740.,  14516.,  16292.,
      15044.,  17204.,  19364.,  21524.,  19124.,  21668.,  24212.,  26756.,
      23204.,  26132.,  29060.,  31988.,  21416.,  23496.,  25576.,  27656.,
      21228.,  23964.,  26700.,  29436.,  43878.,  48270.,  52662.,  57054.,
      53454.,  58422.,  63390.,  68358.,  63030.,  68574.,  74118.,  79662.,
      72606.,  78726.,  84846.,  90966.,  60780.,  65052.,  69324.,  73596.,
      54924.,  59964.,  65004.,  70044.,  101334., 109182., 117030., 124878.,
      110910., 119334., 127758., 136182., 120486., 129486., 138486., 147486.,
      130062., 139638., 149214., 158790., 103692., 110268., 116844., 123420.,
      80296.,  84424.,  88552.,  92680.,  136532., 142916., 149300., 155684.,
      145220., 151988., 158756., 165524., 153908., 161060., 168212., 175364.,
      162596., 170132., 177668., 185204., 122024., 127176., 132328., 137480.,
      57256.,  64456.,  71656.,  78856.,  108884., 119876., 130868., 141860.,
      112964., 124340., 135716., 147092., 117044., 128804., 140564., 152324.,
      121124., 133268., 145412., 157556., 98984.,  107208., 115432., 123656.,
      156012., 167964., 179916., 191868., 273702., 291918., 310134., 328350.,
      283278., 302070., 320862., 339654., 292854., 312222., 331590., 350958.,
      302430., 322374., 342318., 362262., 232428., 245916., 259404., 272892.,
      189708., 203964., 218220., 232476., 331158., 352830., 374502., 396174.,
      340734., 362982., 385230., 407478., 350310., 373134., 395958., 418782.,
      359886., 383286., 406686., 430086., 275340., 291132., 306924., 322716.,
      207016., 217288., 227560., 237832., 345044., 360644., 376244., 391844.,
      353732., 369716., 385700., 401684., 362420., 378788., 395156., 411524.,
      371108., 387860., 404612., 421364., 273320., 284616., 295912., 307208.,
      110248., 123592., 136936., 150280., 206804., 227012., 247220., 267428.,
      210884., 231476., 252068., 272660., 214964., 235940., 256916., 277892.,
      219044., 240404., 261764., 283124., 176552., 190920., 205288., 219656.,
      290796., 311964., 333132., 354300., 503526., 535566., 567606., 599646.,
      513102., 545718., 578334., 610950., 522678., 555870., 589062., 622254.,
      532254., 566022., 599790., 633558., 404076., 426780., 449484., 472188.,
      324492., 347964., 371436., 394908., 560982., 596478., 631974., 667470.,
      570558., 606630., 642702., 678774., 580134., 616782., 653430., 690078.,
      589710., 626934., 664158., 701382., 446988., 471996., 497004., 522012.,
      333736., 350152., 366568., 382984., 553556., 578372., 603188., 628004.,
      562244., 587444., 612644., 637844., 570932., 596516., 622100., 647684.,
      579620., 605588., 631556., 657524., 424616., 442056., 459496., 476936.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,     70.,     110.,    150.,    260.,    404.,    548.,    692.,
      946.,    1258.,   1570.,   1882.,   1834.,   2338.,   2842.,   3346.,
      2532.,   2932.,   3332.,   3732.,   2006.,   2238.,   2470.,   2702.,
      700.,    1036.,   1372.,   1708.,   3592.,   4392.,   5192.,   5992.,
      9188.,   10580.,  11972.,  13364.,  13268.,  15044.,  16820.,  18596.,
      13256.,  14568.,  15880.,  17192.,  9004.,   9724.,   10444.,  11164.,
      4732.,   5068.,   5404.,   5740.,   13192.,  13992.,  14792.,  15592.,
      25892.,  27284.,  28676.,  30068.,  34580.,  36356.,  38132.,  39908.,
      29000.,  30312.,  31624.,  32936.,  17644.,  18364.,  19084.,  19804.,
      7294.,   7590.,   7886.,   8182.,   17348.,  18004.,  18660.,  19316.,
      30418.,  31498.,  32578.,  33658.,  35914.,  37186.,  38458.,  39730.,
      27812.,  28724.,  29636.,  30548.,  15926.,  16414.,  16902.,  17390.,
      350.,    902.,    1454.,   2006.,   2948.,   4116.,   5284.,   6452.,
      8050.,   9898.,   11746.,  13594.,  8938.,   10978.,  13018.,  15058.,
      9316.,   10740.,  12164.,  13588.,  6422.,   7166.,   7910.,   8654.,
      7484.,   8844.,   10204.,  11564.,  21256.,  24104.,  26952.,  29800.,
      41828.,  46292.,  50756.,  55220.,  45908.,  50756.,  55604.,  60452.,
      39112.,  42472.,  45832.,  49192.,  23980.,  25724.,  27468.,  29212.,
      23804.,  25164.,  26524.,  27884.,  55432.,  58280.,  61128.,  63976.,
      95396.,  99860.,  104324., 108788., 104084., 108932., 113780., 118628.,
      79432.,  82792.,  86152.,  89512.,  44908.,  46652.,  48396.,  50140.,
      19902.,  20710.,  21518.,  22326.,  44612.,  46292.,  47972.,  49652.,
      74386.,  77002.,  79618.,  82234.,  79882.,  82690.,  85498.,  88306.,
      59172.,  61108.,  63044.,  64980.,  32630.,  33630.,  34630.,  35630.,
      670.,    1734.,   2798.,   3862.,   5636.,   7828.,   10020.,  12212.,
      15154.,  18538.,  21922.,  25306.,  16042.,  19618.,  23194.,  26770.,
      16100.,  18548.,  20996.,  23444.,  10838.,  12094.,  13350.,  14606.,
      14268.,  16652.,  19036.,  21420.,  38920.,  43816.,  48712.,  53608.,
      74468.,  82004.,  89540.,  97076.,  78548.,  86468.,  94388.,  102308.,
      64968.,  70376.,  75784.,  81192.,  38956.,  41724.,  44492.,  47260.,
      42876.,  45260.,  47644.,  50028.,  97672.,  102568., 107464., 112360.,
      164900., 172436., 179972., 187508., 173588., 181508., 189428., 197348.,
      129864., 135272., 140680., 146088., 72172.,  74940.,  77708.,  80476.,
      32510.,  33830.,  35150.,  36470.,  71876.,  74580.,  77284.,  79988.,
      118354., 122506., 126658., 130810., 123850., 128194., 132538., 136882.,
      90532.,  93492.,  96452.,  99412.,  49334.,  50846.,  52358.,  53870.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29.,   62.,   83.,   75.,   99.,   192.,  237.,  198.,  207.,  372.,
      417.,  330.,  315.,  552.,  597.,  462.,  359.,  602.,  641.,  477.,
      269.,  482.,  503.,  395.,  639.,  1092., 1137., 858.,  747.,  1272.,
      1317., 990.,  855.,  1452., 1497., 1122., 839.,  1382., 1421., 1037.,
      509.,  902.,  923.,  715.,  1179., 1992., 2037., 1518., 1287., 2172.,
      2217., 1650., 1395., 2352., 2397., 1782., 1319., 2162., 2201., 1597.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   4.,   7.,   6.,   7.,   23.,  33.,  24.,  24.,  69.,  90.,  60.,
      41.,  101., 119., 72.,  35.,  82.,  93.,  54.,  7.,   22.,  37.,  24.,
      37.,  95.,  129., 78.,  96.,  231., 288., 168., 107., 245., 287., 162.,
      77.,  172., 195., 108., 13.,  40.,  67.,  42.,  67.,  167., 225., 132.,
      168., 393., 486., 276., 173., 389., 455., 252., 119., 262., 297., 162.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      184.,   412.,   568.,   528.,   678.,   1347.,  1689.,  1434.,  1494.,
      2715.,  3057.,  2442.,  2310.,  4083.,  4425.,  3450.,  2704.,  4552.,
      4852.,  3624.,  1944.,  3532.,  3688.,  2928.,  4758.,  8187.,  8529.,
      6474.,  5574.,  9555.,  9897.,  7482.,  6390.,  10923., 11265., 8490.,
      6384.,  10552., 10852., 7944.,  3704.,  6652.,  6808.,  5328.,  8838.,
      15027., 15369., 11514., 9654.,  16395., 16737., 12522., 10470., 17763.,
      18105., 13530., 10064., 16552., 16852., 12264.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    22.,   42.,   39.,   40.,   144.,  216.,  164.,  153.,  462.,
      618.,  423.,  292.,  728.,  864.,  528.,  257.,  606.,  690.,  403.,
      41.,   142.,  258.,  171.,  256.,  672.,  936.,  572.,  693.,  1686.,
      2130., 1251., 796.,  1832., 2160., 1224., 581.,  1302., 1482., 823.,
      77.,   262.,  474.,  303.,  472.,  1200., 1656., 980.,  1233., 2910.,
      3642., 2079., 1300., 2936., 3456., 1920., 905.,  1998., 2274., 1243.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1288.,  2972.,   4172.,   3944.,  4980.,  10038.,  12702.,  10884.,
      11316., 20694.,  23358.,  18756., 17652., 31350.,  34014.,  26628.,
      20968., 35372.,  37724.,  28232., 14728., 26972.,  28172.,  22504.,
      36660., 63318.,  65982.,  50244., 42996., 73974.,  76638.,  58116.,
      49332., 84630.,  87294.,  65988., 49768., 82412.,  84764.,  62152.,
      28168., 50972.,  52172.,  41064., 68340., 116598., 119262., 89604.,
      74676., 127254., 129918., 97476., 81012., 137910., 140574., 105348.,
      78568., 129452., 131804., 96072.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    140.,   284.,   278.,   260.,   1000.,  1544.,  1204.,  1074.,
      3348.,  4548.,  3162.,  2196.,  5512.,  6568.,  4036.,  1966.,  4652.,
      5308.,  3110.,  270.,   1004.,  1916.,  1286.,  1892.,  5032.,  7112.,
      4372.,  5250.,  12852., 16356., 9642.,  6132.,  14152., 16744., 9508.,
      4510.,  10124., 11548., 6422.,  510.,   1868.,  3548.,  2294.,  3524.,
      9064.,  12680., 7540.,  9426.,  22356., 28164., 16122., 10068., 22792.,
      26920., 14980., 7054.,  15596., 17788., 9734.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      44.,   58.,   100.,  124.,  136.,  166.,  128.,  150.,  165.,  198.,
      330.,  384.,  411.,  474.,  351.,  396.,  357.,  414.,  654.,  744.,
      735.,  834.,  591.,  660.,  549.,  630.,  978.,  1104., 1059., 1194.,
      831.,  924.,  656.,  718.,  1108., 1204., 1180., 1282., 884.,  954.,
      444.,  538.,  820.,  964.,  856.,  1006., 688.,  790.,  1125., 1278.,
      1950., 2184., 2031., 2274., 1551., 1716., 1317., 1494., 2274., 2544.,
      2355., 2634., 1791., 1980., 1509., 1710., 2598., 2904., 2679., 2994.,
      2031., 2244., 1536., 1678., 2548., 2764., 2620., 2842., 1924., 2074.,
      844.,  1018., 1540., 1804., 1576., 1846., 1248., 1430., 2085., 2358.,
      3570., 3984., 3651., 4074., 2751., 3036., 2277., 2574., 3894., 4344.,
      3975., 4434., 2991., 3300., 2469., 2790., 4218., 4704., 4299., 4794.,
      3231., 3564., 2416., 2638., 3988., 4324., 4060., 4402., 2964., 3194.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   5.,   8.,   11.,  14.,  10.,  12.,  10.,  14.,  36.,  46.,
      56.,  66.,  42.,  48.,  39.,  48.,  117., 138., 159., 180., 108., 120.,
      74.,  82.,  184., 202., 220., 238., 134., 144., 65.,  70.,  153., 164.,
      175., 186., 102., 108., 7.,   14.,  29.,  44.,  59.,  74.,  40.,  48.,
      58.,  74.,  156., 190., 224., 258., 138., 156., 165., 192., 405., 462.,
      519., 576., 306., 336., 194., 214., 448., 490., 532., 574., 302., 324.,
      143., 154., 321., 344., 367., 390., 204., 216., 13.,  26.,  53.,  80.,
      107., 134., 70.,  84.,  106., 134., 276., 334., 392., 450., 234., 264.,
      291., 336., 693., 786., 879., 972., 504., 552., 314., 346., 712., 778.,
      844., 910., 470., 504., 221., 238., 489., 524., 559., 594., 306., 324.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      288.,   392.,   686.,   866.,   962.,   1190.,  928.,   1096.,  1164.,
      1416.,  2379.,  2793.,  3009.,  3495.,  2604.,  2952.,  2652.,  3096.,
      4899.,  5601.,  5529.,  6303.,  4476.,  5016.,  4140.,  4776.,  7419.,
      8409.,  8049.,  9111.,  6348.,  7080.,  5040.,  5528.,  8534.,  9290.,
      9098.,  9902.,  6832.,  7384.,  3328.,  4072.,  6206.,  7346.,  6482.,
      7670.,  5248.,  6056.,  8604.,  9816.,  14979., 16833., 15609., 17535.,
      11964., 13272., 10092., 11496., 17499., 19641., 18129., 20343., 13836.,
      15336., 11580., 13176., 20019., 22449., 20649., 23151., 15708., 17400.,
      11920., 13048., 19814., 21530., 20378., 22142., 14992., 16184., 6368.,
      7752.,  11726., 13826., 12002., 14150., 9568.,  11016., 16044., 18216.,
      27579., 30873., 28209., 31575., 21324., 23592., 17532., 19896., 30099.,
      33681., 30729., 34383., 23196., 25656., 19020., 21576., 32619., 36489.,
      33249., 37191., 25068., 27720., 18800., 20568., 31094., 33770., 31658.,
      34382., 23152., 24984.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    11.,   28.,   48.,   68.,   88.,   67.,   81.,   58.,   86.,
      232.,  304.,  376.,  448.,  294.,  338.,  255.,  321.,  804.,  960.,
      1116., 1272., 777.,  867.,  538.,  598.,  1352., 1488., 1624., 1760.,
      998.,  1074., 485.,  523.,  1148., 1232., 1316., 1400., 771.,  817.,
      41.,   95.,   196.,  312.,  428.,  544.,  295.,  357.,  418.,  542.,
      1144., 1408., 1672., 1936., 1038., 1178., 1227., 1437., 3036., 3480.,
      3924., 4368., 2325., 2559., 1474., 1630., 3416., 3744., 4072., 4400.,
      2318., 2490., 1097., 1183., 2468., 2648., 2828., 3008., 1575., 1669.,
      77.,   179.,  364.,  576.,  788.,  1000., 523.,  633.,  778.,  998.,
      2056., 2512., 2968., 3424., 1782., 2018., 2199., 2553., 5268., 6000.,
      6732., 7464., 3873., 4251., 2410., 2662., 5480., 6000., 6520., 7040.,
      3638., 3906., 1709., 1843., 3788., 4064., 4340., 4616., 2379., 2521.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2056.,   2856.,   5044.,   6436.,   7204.,   8980.,   7048.,   8360.,
      8700.,   10668.,  18006.,  21246.,  22974.,  26790.,  20028.,  22764.,
      20412.,  23916.,  37878.,  43422.,  42846.,  48966.,  34812.,  39084.,
      32124.,  37164.,  57750.,  65598.,  62718.,  71142.,  49596.,  55404.,
      39496.,  43368.,  66964.,  72964.,  71428.,  77812.,  53704.,  58088.,
      25736.,  31656.,  48244.,  57316.,  50404.,  59860.,  40968.,  47400.,
      67260.,  76908.,  117366., 132126., 122334., 137670., 93948.,  104364.,
      78972.,  90156.,  137238., 154302., 142206., 159846., 108732., 120684.,
      90684.,  103404., 157110., 176478., 162078., 182022., 123516., 137004.,
      93896.,  102888., 156244., 169924., 160708., 174772., 118344., 127848.,
      49416.,  60456.,  91444.,  108196., 93604.,  110740., 74888.,  86440.,
      125820., 143148., 216726., 243006., 221694., 248550., 167868., 185964.,
      137532., 156396., 236598., 265182., 241566., 270726., 182652., 202284.,
      149244., 169644., 256470., 287358., 261438., 292902., 197436., 218604.,
      148296., 162408., 245524., 266884., 249988., 271732., 182984., 197608.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    70.,    180.,   324.,   468.,   612.,   486.,   590.,   380.,
      588.,   1640.,  2184.,  2728.,  3272.,  2188.,  2524.,  1818.,  2322.,
      5916.,  7116.,  8316.,  9516.,  5874.,  6570.,  4092.,  4556.,  10344.,
      11400., 12456., 13512., 7692.,  8284.,  3742.,  4038.,  8884.,  9540.,
      10196., 10852., 5990.,  6350.,  270.,   694.,   1428.,  2340.,  3252.,
      4164.,  2262.,  2750.,  3164.,  4140.,  8744.,  10824., 12904., 14984.,
      8044.,  9148.,  9450.,  11106., 23484., 26988., 30492., 33996., 18114.,
      19962., 11484., 12716., 26664., 29256., 31848., 34440., 18156., 19516.,
      8590.,  9270.,  19348., 20772., 22196., 23620., 12374., 13118., 510.,
      1318.,  2676.,  4356.,  6036.,  7716.,  4038.,  4910.,  5948.,  7692.,
      15848., 19464., 23080., 26696., 13900., 15772., 17082., 19890., 41052.,
      46860., 52668., 58476., 30354., 33354., 18876., 20876., 42984., 47112.,
      51240., 55368., 28620., 30748., 13438., 14502., 29812., 32004., 34196.,
      36388., 18758., 19886.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      74.,   88.,   102.,  116.,  176.,  200.,  224.,  248.,  242.,  272.,
      302.,  332.,  234.,  256.,  278.,  300.,  297.,  330.,  363.,  396.,
      606.,  660.,  714.,  768.,  759.,  822.,  885.,  948.,  657.,  702.,
      747.,  792.,  657.,  714.,  771.,  828.,  1218., 1308., 1398., 1488.,
      1371., 1470., 1569., 1668., 1113., 1182., 1251., 1320., 1017., 1098.,
      1179., 1260., 1830., 1956., 2082., 2208., 1983., 2118., 2253., 2388.,
      1569., 1662., 1755., 1848., 1250., 1312., 1374., 1436., 2120., 2216.,
      2312., 2408., 2258., 2360., 2462., 2564., 1698., 1768., 1838., 1908.,
      794.,  888.,  982.,  1076., 1496., 1640., 1784., 1928., 1562., 1712.,
      1862., 2012., 1274., 1376., 1478., 1580., 2097., 2250., 2403., 2556.,
      3666., 3900., 4134., 4368., 3819., 4062., 4305., 4548., 2937., 3102.,
      3267., 3432., 2457., 2634., 2811., 2988., 4278., 4548., 4818., 5088.,
      4431., 4710., 4989., 5268., 3393., 3582., 3771., 3960., 2817., 3018.,
      3219., 3420., 4890., 5196., 5502., 5808., 5043., 5358., 5673., 5988.,
      3849., 4062., 4275., 4488., 2930., 3072., 3214., 3356., 4880., 5096.,
      5312., 5528., 5018., 5240., 5462., 5684., 3698., 3848., 3998., 4148.,
      1514., 1688., 1862., 2036., 2816., 3080., 3344., 3608., 2882., 3152.,
      3422., 3692., 2314., 2496., 2678., 2860., 3897., 4170., 4443., 4716.,
      6726., 7140., 7554., 7968., 6879., 7302., 7725., 8148., 5217., 5502.,
      5787., 6072., 4257., 4554., 4851., 5148., 7338., 7788., 8238., 8688.,
      7491., 7950., 8409., 8868., 5673., 5982., 6291., 6600., 4617., 4938.,
      5259., 5580., 7950., 8436., 8922., 9408., 8103., 8598., 9093., 9588.,
      6129., 6462., 6795., 7128., 4610., 4832., 5054., 5276., 7640., 7976.,
      8312., 8648., 7778., 8120., 8462., 8804., 5698., 5928., 6158., 6388.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    2.,    3.,    4.,    7.,    10.,   13.,   16.,   19.,   22.,
      25.,   28.,   18.,   20.,   22.,   24.,   16.,   20.,   24.,   28.,
      62.,   72.,   82.,   92.,   102.,  112.,  122.,  132.,  78.,   84.,
      90.,   96.,   69.,   78.,   87.,   96.,   213.,  234.,  255.,  276.,
      297.,  318.,  339.,  360.,  204.,  216.,  228.,  240.,  140.,  148.,
      156.,  164.,  350.,  368.,  386.,  404.,  422.,  440.,  458.,  476.,
      258.,  268.,  278.,  288.,  125.,  130.,  135.,  140.,  295.,  306.,
      317.,  328.,  339.,  350.,  361.,  372.,  198.,  204.,  210.,  216.,
      7.,    14.,   21.,   28.,   43.,   58.,   73.,   88.,   103.,  118.,
      133.,  148.,  72.,   80.,   88.,   96.,   100.,  116.,  132.,  148.,
      278.,  312.,  346.,  380.,  414.,  448.,  482.,  516.,  258.,  276.,
      294.,  312.,  303.,  330.,  357.,  384.,  753.,  810.,  867.,  924.,
      981.,  1038., 1095., 1152., 582.,  612.,  642.,  672.,  368.,  388.,
      408.,  428.,  854.,  896.,  938.,  980.,  1022., 1064., 1106., 1148.,
      582.,  604.,  626.,  648.,  275.,  286.,  297.,  308.,  619.,  642.,
      665.,  688.,  711.,  734.,  757.,  780.,  396.,  408.,  420.,  432.,
      13.,   26.,   39.,   52.,   79.,   106.,  133.,  160.,  187.,  214.,
      241.,  268.,  126.,  140.,  154.,  168.,  184.,  212.,  240.,  268.,
      494.,  552.,  610.,  668.,  726.,  784.,  842.,  900.,  438.,  468.,
      498.,  528.,  537.,  582.,  627.,  672.,  1293., 1386., 1479., 1572.,
      1665., 1758., 1851., 1944., 960.,  1008., 1056., 1104., 596.,  628.,
      660.,  692.,  1358., 1424., 1490., 1556., 1622., 1688., 1754., 1820.,
      906.,  940.,  974.,  1008., 425.,  442.,  459.,  476.,  943.,  978.,
      1013., 1048., 1083., 1118., 1153., 1188., 594.,  612.,  630.,  648.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      496.,   600.,   704.,   808.,   1234.,  1414.,  1594.,  1774.,  1750.,
      1978.,  2206.,  2434.,  1728.,  1896.,  2064.,  2232.,  2136.,  2388.,
      2640.,  2892.,  4443.,  4857.,  5271.,  5685.,  5649.,  6135.,  6621.,
      7107.,  4944.,  5292.,  5640.,  5988.,  4968.,  5412.,  5856.,  6300.,
      9267.,  9969.,  10671., 11373., 10473., 11247., 12021., 12795., 8544.,
      9084.,  9624.,  10164., 7800.,  8436.,  9072.,  9708.,  14091., 15081.,
      16071., 17061., 15297., 16359., 17421., 18483., 12144., 12876., 13608.,
      14340., 9712.,  10200., 10688., 11176., 16498., 17254., 18010., 18766.,
      17590., 18394., 19198., 20002., 13248., 13800., 14352., 14904., 6096.,
      6840.,  7584.,  8328.,  11554., 12694., 13834., 14974., 12070., 13258.,
      14446., 15634., 9888.,  10696., 11504., 12312., 16296., 17508., 18720.,
      19932., 28563., 30417., 32271., 34125., 29769., 31695., 33621., 35547.,
      22944., 24252., 25560., 26868., 19128., 20532., 21936., 23340., 33387.,
      35529., 37671., 39813., 34593., 36807., 39021., 41235., 26544., 28044.,
      29544., 31044., 21960., 23556., 25152., 26748., 38211., 40641., 43071.,
      45501., 39417., 41919., 44421., 46923., 30144., 31836., 33528., 35220.,
      22992., 24120., 25248., 26376., 38338., 40054., 41770., 43486., 39430.,
      41194., 42958., 44722., 29088., 30280., 31472., 32664., 11696., 13080.,
      14464., 15848., 21874., 23974., 26074., 28174., 22390., 24538., 26686.,
      28834., 18048., 19496., 20944., 22392., 30456., 32628., 34800., 36972.,
      52683., 55977., 59271., 62565., 53889., 57255., 60621., 63987., 40944.,
      43212., 45480., 47748., 33288., 35652., 38016., 40380., 57507., 61089.,
      64671., 68253., 58713., 62367., 66021., 69675., 44544., 47004., 49464.,
      51924., 36120., 38676., 41232., 43788., 62331., 66201., 70071., 73941.,
      63537., 67479., 71421., 75363., 48144., 50796., 53448., 56100., 36272.,
      38040., 39808., 41576., 60178., 62854., 65530., 68206., 61270., 63994.,
      66718., 69442., 44928., 46760., 48592., 50424.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,     11.,    17.,    23.,    40.,    60.,    80.,    100.,   120.,
      140.,   160.,   180.,   123.,   137.,   151.,   165.,   94.,    122.,
      150.,   178.,   408.,   480.,   552.,   624.,   696.,   768.,   840.,
      912.,   554.,   598.,   642.,   686.,   459.,   525.,   591.,   657.,
      1488.,  1644.,  1800.,  1956.,  2112.,  2268.,  2424.,  2580.,  1485.,
      1575.,  1665.,  1755.,  1030.,  1090.,  1150.,  1210.,  2600.,  2736.,
      2872.,  3008.,  3144.,  3280.,  3416.,  3552.,  1938.,  2014.,  2090.,
      2166.,  941.,   979.,   1017.,  1055.,  2232.,  2316.,  2400.,  2484.,
      2568.,  2652.,  2736.,  2820.,  1507.,  1553.,  1599.,  1645.,  41.,
      95.,    149.,   203.,   304.,   420.,   536.,   652.,   768.,   884.,
      1000.,  1116.,  543.,   605.,   667.,   729.,   742.,   866.,   990.,
      1114.,  2088.,  2352.,  2616.,  2880.,  3144.,  3408.,  3672.,  3936.,
      1970.,  2110.,  2250.,  2390.,  2295.,  2505.,  2715.,  2925.,  5736.,
      6180.,  6624.,  7068.,  7512.,  7956.,  8400.,  8844.,  4473.,  4707.,
      4941.,  5175.,  2830.,  2986.,  3142.,  3298.,  6584.,  6912.,  7240.,
      7568.,  7896.,  8224.,  8552.,  8880.,  4506.,  4678.,  4850.,  5022.,
      2129.,  2215.,  2301.,  2387.,  4800.,  4980.,  5160.,  5340.,  5520.,
      5700.,  5880.,  6060.,  3079.,  3173.,  3267.,  3361.,  77.,    179.,
      281.,   383.,   568.,   780.,   992.,   1204.,  1416.,  1628.,  1840.,
      2052.,  963.,   1073.,  1183.,  1293.,  1390.,  1610.,  1830.,  2050.,
      3768.,  4224.,  4680.,  5136.,  5592.,  6048.,  6504.,  6960.,  3386.,
      3622.,  3858.,  4094.,  4131.,  4485.,  4839.,  5193.,  9984.,  10716.,
      11448., 12180., 12912., 13644., 14376., 15108., 7461.,  7839.,  8217.,
      8595.,  4630.,  4882.,  5134.,  5386.,  10568., 11088., 11608., 12128.,
      12648., 13168., 13688., 14208., 7074.,  7342.,  7610.,  7878.,  3317.,
      3451.,  3585.,  3719.,  7368.,  7644.,  7920.,  8196.,  8472.,  8748.,
      9024.,  9300.,  4651.,  4793.,  4935.,  5077.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3592.,   4392.,   5192.,   5992.,   9188.,   10580.,  11972.,  13364.,
      13268.,  15044.,  16820.,  18596.,  13256.,  14568.,  15880.,  17192.,
      16140.,  18108.,  20076.,  22044.,  33942.,  37182.,  40422.,  43662.,
      43518.,  47334.,  51150.,  54966.,  38316.,  41052.,  43788.,  46524.,
      38604.,  42108.,  45612.,  49116.,  72246.,  77790.,  83334.,  88878.,
      81822.,  87942.,  94062.,  100182., 66924.,  71196.,  75468.,  79740.,
      61068.,  66108.,  71148.,  76188.,  110550., 118398., 126246., 134094.,
      120126., 128550., 136974., 145398., 95532.,  101340., 107148., 112956.,
      76552.,  80424.,  84296.,  88168.,  130148., 136148., 142148., 148148.,
      138836., 145220., 151604., 157988., 104648., 109032., 113416., 117800.,
      47752.,  53672.,  59592.,  65512.,  90788.,  99860.,  108932., 118004.,
      94868.,  104324., 113780., 123236., 77896.,  84328.,  90760.,  97192.,
      128460., 138108., 147756., 157404., 225462., 240222., 254982., 269742.,
      235038., 250374., 265710., 281046., 181356., 191772., 202188., 212604.,
      150924., 162108., 173292., 184476., 263766., 280830., 297894., 314958.,
      273342., 290982., 308622., 326262., 209964., 221916., 233868., 245820.,
      173388., 186108., 198828., 211548., 302070., 321438., 340806., 360174.,
      311646., 331590., 351534., 371478., 238572., 252060., 265548., 279036.,
      182152., 191144., 200136., 209128., 303908., 317588., 331268., 344948.,
      312596., 326660., 340724., 354788., 230728., 240232., 249736., 259240.,
      91912.,  102952., 113992., 125032., 172388., 189140., 205892., 222644.,
      176468., 193604., 210740., 227876., 142536., 154088., 165640., 177192.,
      240780., 258108., 275436., 292764., 416982., 443262., 469542., 495822.,
      426558., 453414., 480270., 507126., 324396., 342492., 360588., 378684.,
      263244., 282108., 300972., 319836., 455286., 483870., 512454., 541038.,
      464862., 494022., 523182., 552342., 353004., 372636., 392268., 411900.,
      285708., 306108., 326508., 346908., 493590., 524478., 555366., 586254.,
      503166., 534630., 566094., 597558., 381612., 402780., 423948., 445116.,
      287752., 301864., 315976., 330088., 477668., 499028., 520388., 541748.,
      486356., 508100., 529844., 551588., 356808., 371432., 386056., 400680.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,     70.,     110.,    150.,    260.,   404.,   548.,   692.,
      836.,    980.,    1124.,   1268.,   902.,   1006.,  1110.,  1214.,
      620.,    828.,    1036.,   1244.,   2920.,  3464.,  4008.,  4552.,
      5096.,   5640.,   6184.,   6728.,   4156.,  4492.,  4828.,  5164.,
      3306.,   3810.,   4314.,   4818.,   11052., 12252., 13452., 14652.,
      15852.,  17052.,  18252.,  19452.,  11298., 11994., 12690., 13386.,
      7884.,   8348.,   8812.,   9276.,   20008., 21064., 22120., 23176.,
      24232.,  25288.,  26344.,  27400.,  15004., 15596., 16188., 16780.,
      7294.,   7590.,   7886.,   8182.,   17348., 18004., 18660., 19316.,
      19972.,  20628.,  21284.,  21940.,  11750., 12110., 12470., 12830.,
      270.,    694.,    1118.,   1542.,   2276.,  3188.,  4100.,  5012.,
      5924.,   6836.,   7748.,   8660.,   4214.,  4702.,  5190.,  5678.,
      5708.,   6684.,   7660.,   8636.,   16168., 18248., 20328., 22408.,
      24488.,  26568.,  28648.,  30728.,  15388., 16492., 17596., 18700.,
      17850.,  19506.,  21162.,  22818.,  44748., 48252., 51756., 55260.,
      58764.,  62268.,  65772.,  69276.,  35058., 36906., 38754., 40602.,
      22188.,  23420.,  24652.,  25884.,  51688., 54280., 56872., 59464.,
      62056.,  64648.,  67240.,  69832.,  35452., 36812., 38172., 39532.,
      16750.,  17430.,  18110.,  18790.,  37796., 39220., 40644., 42068.,
      43492.,  44916.,  46340.,  47764.,  24278., 25022., 25766., 26510.,
      510.,    1318.,   2126.,   2934.,   4292.,  5972.,  7652.,  9332.,
      11012.,  12692.,  14372.,  16052.,  7526.,  8398.,  9270.,  10142.,
      10796.,  12540.,  14284.,  16028.,  29416., 33032., 36648., 40264.,
      43880.,  47496.,  51112.,  54728.,  26620., 28492., 30364., 32236.,
      32394.,  35202.,  38010.,  40818.,  78444., 84252., 90060., 95868.,
      101676., 107484., 113292., 119100., 58818., 61818., 64818., 67818.,
      36492.,  38492.,  40492.,  42492.,  83368., 87496., 91624., 95752.,
      99880.,  104008., 108136., 112264., 55900., 58028., 60156., 62284.,
      26206.,  27270.,  28334.,  29398.,  58244., 60436., 62628., 64820.,
      67012.,  69204.,  71396.,  73588.,  36806., 37934., 39062., 40190.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      32.,   68.,   89.,   110.,  96.,   114.,  219.,  264.,  309.,  252.,
      249.,  444.,  489.,  534.,  417.,  384.,  669.,  714.,  759.,  582.,
      440.,  734.,  773.,  812.,  600.,  332.,  593.,  614.,  635.,  496.,
      789.,  1344., 1389., 1434., 1077., 924.,  1569., 1614., 1659., 1242.,
      1059., 1794., 1839., 1884., 1407., 1040., 1709., 1748., 1787., 1300.,
      632.,  1118., 1139., 1160., 896.,  1464., 2469., 2514., 2559., 1902.,
      1599., 2694., 2739., 2784., 2067., 1734., 2919., 2964., 3009., 2232.,
      1640., 2684., 2723., 2762., 2000.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   4.,   10.,  12.,  9.,   8.,   26.,  56.,  54.,  36.,  30.,
      84.,  165., 144., 90.,  56.,  134., 236., 186., 108., 49.,  112.,
      190., 144., 81.,  10.,  31.,  64.,  57.,  36.,  53.,  134., 245.,
      198., 117., 138., 327., 570., 441., 252., 155., 350., 587., 438.,
      243., 112., 247., 406., 297., 162., 19.,  58.,  118., 102., 63.,
      98.,  242., 434., 342., 198., 246., 570., 975., 738., 414., 254.,
      566., 938., 690., 378., 175., 382., 622., 450., 243.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      204.,   454.,   610.,   766.,   684.,   786.,   1545.,  1887.,  2229.,
      1842.,  1806.,  3255.,  3597.,  3939.,  3102.,  2826.,  4965.,  5307.,
      5649.,  4362.,  3324.,  5566.,  5866.,  6166.,  4572.,  2404.,  4354.,
      4510.,  4666.,  3684.,  5886.,  10095., 10437., 10779., 8142.,  6906.,
      11805., 12147., 12489., 9402.,  7926.,  13515., 13857., 14199., 10662.,
      7924.,  13066., 13366., 13666., 9972.,  4604.,  8254.,  8410.,  8566.,
      6684.,  10986., 18645., 18987., 19329., 14442., 12006., 20355., 20697.,
      21039., 15702., 13026., 22065., 22407., 22749., 16962., 12524., 20566.,
      20866., 21166., 15372.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    22.,   59.,   78.,   61.,   46.,   164.,  370.,  372.,  254.,
      195.,  570.,  1149., 1026., 651.,  406.,  980.,  1738., 1380., 806.,
      365.,  838.,  1427., 1086., 613.,  59.,   202.,  437.,  402.,  259.,
      370.,  956.,  1774., 1452., 866.,  1005., 2406., 4227., 3294., 1893.,
      1162., 2636., 4438., 3324., 1850., 851.,  1882., 3101., 2274., 1243.,
      113.,  382.,  815.,  726.,  457.,  694.,  1748., 3178., 2532., 1478.,
      1815., 4242., 7305., 5562., 3135., 1918., 4292., 7138., 5268., 2894.,
      1337., 2926., 4775., 3462., 1873.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1432.,   3284.,   4484.,   5684.,   5144.,   5796.,   11550.,  14214.,
      16878.,  14052.,  13716.,  24870.,  27534.,  30198.,  23892.,  21636.,
      38190.,  40854.,  43518.,  33732.,  25816.,  43316.,  45668.,  48020.,
      35672.,  18232.,  33284.,  34484.,  35684.,  28344.,  45396.,  78150.,
      80814.,  83478.,  63252.,  53316.,  91470.,  94134.,  96798.,  73092.,
      61236.,  104790., 107454., 110118., 82932.,  61816.,  102116., 104468.,
      106820., 78072.,  35032.,  63284.,  64484.,  65684.,  51544.,  84996.,
      144750., 147414., 150078., 112452., 92916.,  158070., 160734., 163398.,
      122292., 100836., 171390., 174054., 176718., 132132., 97816.,  160916.,
      163268., 165620., 120472.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    140.,   394.,   556.,   446.,   300.,   1144.,  2660.,  2744.,
      1900.,  1386.,  4164.,  8526.,  7716.,  4938.,  3084.,  7480.,  13316.,
      10616., 6220.,  2814.,  6476.,  11050., 8428.,  4766.,  390.,   1436.,
      3202.,  3004.,  1958.,  2748.,  7192.,  13460., 11096., 6652.,  7650.,
      18420., 32502., 25428., 14658., 8988.,  20440., 34484., 25880., 14428.,
      6630.,  14684., 24226., 17788., 9734.,  750.,   2732.,  6010.,  5452.,
      3470.,  5196.,  13240., 24260., 19448., 11404., 13914., 32676., 56478.,
      43140., 24378., 14892., 33400., 55652., 41144., 22636., 10446., 22892.,
      37402., 27148., 14702.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      48.,   64.,   109.,  136.,  145.,  178.,  181.,  220.,  164.,  192.,
      189.,  228.,  375.,  438.,  456.,  528.,  537.,  618.,  447.,  504.,
      429.,  498.,  780.,  888.,  861.,  978.,  942.,  1068., 747.,  834.,
      669.,  768.,  1185., 1338., 1266., 1428., 1347., 1518., 1047., 1164.,
      804.,  880.,  1351., 1468., 1423., 1546., 1495., 1624., 1112., 1200.,
      548.,  664.,  1009., 1186., 1045., 1228., 1081., 1270., 864.,  992.,
      1389., 1578., 2400., 2688., 2481., 2778., 2562., 2868., 1947., 2154.,
      1629., 1848., 2805., 3138., 2886., 3228., 2967., 3318., 2247., 2484.,
      1869., 2118., 3210., 3588., 3291., 3678., 3372., 3768., 2547., 2814.,
      1904., 2080., 3151., 3418., 3223., 3496., 3295., 3574., 2412., 2600.,
      1048., 1264., 1909., 2236., 1945., 2278., 1981., 2320., 1564., 1792.,
      2589., 2928., 4425., 4938., 4506., 5028., 4587., 5118., 3447., 3804.,
      2829., 3198., 4830., 5388., 4911., 5478., 4992., 5568., 3747., 4134.,
      3069., 3468., 5235., 5838., 5316., 5928., 5397., 6018., 4047., 4464.,
      3004., 3280., 4951., 5368., 5023., 5446., 5095., 5524., 3712., 4000.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   5.,    8.,    14.,   20.,   19.,   24.,   15.,  18.,
      11.,  16.,  40.,   52.,   91.,   112.,  92.,   108.,  63.,  72.,
      48.,  60.,  141.,  168.,  285.,  330.,  255.,  288.,  162., 180.,
      101., 112., 244.,  268.,  433.,  472.,  344.,  372.,  201., 216.,
      91.,  98.,  209.,  224.,  356.,  380.,  271.,  288.,  153., 162.,
      10.,  20.,  41.,   62.,   95.,   128.,  91.,   114.,  60.,  72.,
      83.,  106., 220.,  268.,  415.,  490.,  344.,  396.,  207., 234.,
      237., 276., 573.,  654.,  1014., 1140., 795.,  882.,  459., 504.,
      281., 310., 640.,  700.,  1081., 1174., 812.,  876.,  453., 486.,
      208., 224., 461.,  494.,  761.,  812.,  559.,  594.,  306., 324.,
      19.,  38.,  77.,   116.,  176.,  236.,  163.,  204.,  105., 126.,
      155., 196., 400.,  484.,  739.,  868.,  596.,  684.,  351., 396.,
      426., 492., 1005., 1140., 1743., 1950., 1335., 1476., 756., 828.,
      461., 508., 1036., 1132., 1729., 1876., 1280., 1380., 705., 756.,
      325., 350., 713.,  764.,  1166., 1244., 847.,  900.,  459., 486.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      316.,   436.,   752.,   956.,   1028.,  1280.,  1304.,  1604.,  1204.,
      1420.,  1344.,  1644.,  2721.,  3207.,  3351.,  3909.,  3981.,  4611.,
      3348.,  3792.,  3204.,  3744.,  5871.,  6717.,  6501.,  7419.,  7131.,
      8121.,  5688.,  6372.,  5064.,  5844.,  9021.,  10227., 9651.,  10929.,
      10281., 11631., 8028.,  8952.,  6196.,  6796.,  10436., 11360., 11000.,
      11972., 11564., 12584., 8620.,  9316.,  4116.,  5036.,  7652.,  9056.,
      7928.,  9380.,  8204.,  9704.,  6604.,  7620.,  10644., 12144., 18471.,
      20757., 19101., 21459., 19731., 22161., 15048., 16692., 12504., 14244.,
      21621., 24267., 22251., 24969., 22881., 25671., 17388., 19272., 14364.,
      16344., 24771., 27777., 25401., 28479., 26031., 29181., 19728., 21852.,
      14796., 16196., 24536., 26660., 25100., 27272., 25664., 27884., 18820.,
      20316., 7916.,  9636.,  14552., 17156., 14828., 17480., 15104., 17804.,
      12004., 13820., 19944., 22644., 34221., 38307., 34851., 39009., 35481.,
      39711., 26748., 29592., 21804., 24744., 37371., 41817., 38001., 42519.,
      38631., 43221., 29088., 32172., 23664., 26844., 40521., 45327., 41151.,
      46029., 41781., 46731., 31428., 34752., 23396., 25596., 38636., 41960.,
      39200., 42572., 39764., 43184., 29020., 31316.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    11.,   28.,   48.,   85.,    127.,   128.,   164.,   105.,  127.,
      64.,   100.,  260.,  348.,  620.,   776.,   652.,   772.,   456.,  524.,
      321.,  411.,  984.,  1188., 2037.,  2379.,  1860.,  2112.,  1197., 1335.,
      748.,  832.,  1820., 2004., 3248.,  3548.,  2596.,  2812.,  1524., 1640.,
      689.,  743.,  1588., 1704., 2713.,  2899.,  2072.,  2204.,  1173., 1243.,
      59.,   137.,  280.,  444.,  679.,   937.,   668.,   848.,   447.,  541.,
      604.,  784.,  1628., 2004., 3104.,  3692.,  2596.,  3004.,  1572., 1784.,
      1779., 2085., 4332., 4968., 7707.,  8697.,  6072.,  6756.,  3519., 3873.,
      2152., 2380., 4916., 5388., 8324.,  9056.,  6268.,  6772.,  3504., 3764.,
      1607., 1733., 3568., 3828., 5899.,  6301.,  4340.,  4616.,  2379., 2521.,
      113.,  263.,  532.,  840.,  1273.,  1747.,  1208.,  1532.,  789.,  955.,
      1144., 1468., 2996., 3660., 5588.,  6608.,  4540.,  5236.,  2688., 3044.,
      3237., 3759., 7680., 8748., 13377., 15015., 10284., 11400., 5841., 6411.,
      3556., 3928., 8012., 8772., 13400., 14564., 9940.,  10732., 5484., 5888.,
      2525., 2723., 5548., 5952., 9085.,  9703.,  6608.,  7028.,  3585., 3799.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2264.,   3192.,   5548.,   7132.,   7708.,   9676.,   9868.,   12220.,
      9208.,   10904.,  10092.,  12444.,  20670.,  24486.,  25638.,  30030.,
      30606.,  35574.,  25884.,  29388.,  24732.,  29004.,  45510.,  52206.,
      50478.,  57750.,  55446.,  63294.,  44364.,  49788.,  39372.,  45564.,
      70350.,  79926.,  75318.,  85470.,  80286.,  91014.,  62844.,  70188.,
      48632.,  53400.,  82012.,  89356.,  86476.,  94204.,  90940.,  99052.,
      67864.,  73400.,  31864.,  39192.,  59548.,  70732.,  61708.,  73276.,
      63868.,  75820.,  51608.,  59704.,  83292.,  95244.,  144870., 163086.,
      149838., 168630., 154806., 174174., 118284., 131388., 97932.,  111804.,
      169710., 190806., 174678., 196350., 179646., 201894., 136764., 151788.,
      112572., 128364., 194550., 218526., 199518., 224070., 204486., 229614.,
      155244., 172188., 116632., 127800., 193612., 210556., 198076., 215404.,
      202540., 220252., 148664., 160600., 61464.,  75192.,  113548., 134332.,
      115708., 136876., 117868., 139420., 94008.,  108504., 156492., 178044.,
      269070., 301686., 274038., 307230., 279006., 312774., 210684., 233388.,
      171132., 194604., 293910., 329406., 298878., 334950., 303846., 340494.,
      229164., 253788., 185772., 211164., 318750., 357126., 323718., 362670.,
      328686., 368214., 247644., 274188., 184632., 202200., 305212., 331756.,
      309676., 336604., 314140., 341452., 229464., 247800.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,     70.,    180.,   324.,   578.,   890.,   932.,   1204.,   782.,
      950.,    420.,   692.,   1848.,  2520.,  4540.,  5740.,  4888.,   5816.,
      3460.,   3988.,  2322.,  3018.,  7308.,  8892.,  15342., 18006.,  14172.,
      16140.,  9186.,  10266., 5748.,  6404.,  14040., 15480., 25132.,  27484.,
      20152.,  21848., 11860., 12772., 5358.,  5782.,  12372., 13284.,  21170.,
      22634.,  16196., 17236., 9182.,  9734.,  390.,   1006.,  2052.,   3348.,
      5114.,   7154.,  5108.,  6532.,  3446.,  4190.,  4596.,  6020.,   12504.,
      15480.,  23980., 28636., 20152., 23384., 12244., 13924., 13770.,  16194.,
      33660.,  38700., 60054., 67902., 47436., 52860., 27546., 30354.,  16836.,
      18644.,  38520., 42264., 65308., 71116., 49240., 53240., 27556.,  29620.,
      12630.,  13630., 28068., 30132., 46442., 49634., 34196., 36388.,  18758.,
      19886.,  750.,   1942.,  3924.,  6372.,  9650.,  13418., 9284.,   11860.,
      6110.,   7430.,  8772.,  11348., 23160., 28440., 43420., 51532.,  35416.,
      40952.,  21028., 23860., 25218., 29370., 60012., 68508., 104766., 117798.,
      80700.,  89580., 45906., 50442., 27924., 30884., 63000., 69048.,  105484.,
      114748., 78328., 84632., 43252., 46468., 19902., 21478., 43764.,  46980.,
      71714.,  76634., 52196., 55540., 28334., 30038.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      80.,    96.,    112.,   128.,   191.,   218.,   245.,   272.,   257.,
      290.,   323.,   356.,   323.,   362.,   401.,   440.,   300.,   328.,
      356.,   384.,   339.,   378.,   417.,   456.,   687.,   750.,   813.,
      876.,   840.,   912.,   984.,   1056.,  993.,   1074.,  1155.,  1236.,
      837.,   894.,   951.,   1008.,  789.,   858.,   927.,   996.,   1452.,
      1560.,  1668.,  1776.,  1605.,  1722.,  1839.,  1956.,  1758.,  1884.,
      2010.,  2136.,  1407.,  1494.,  1581.,  1668.,  1239.,  1338.,  1437.,
      1536.,  2217.,  2370.,  2523.,  2676.,  2370.,  2532.,  2694.,  2856.,
      2523.,  2694.,  2865.,  3036.,  1977.,  2094.,  2211.,  2328.,  1532.,
      1608.,  1684.,  1760.,  2585.,  2702.,  2819.,  2936.,  2723.,  2846.,
      2969.,  3092.,  2861.,  2990.,  3119.,  3248.,  2136.,  2224.,  2312.,
      2400.,  980.,   1096.,  1212.,  1328.,  1841.,  2018.,  2195.,  2372.,
      1907.,  2090.,  2273.,  2456.,  1973.,  2162.,  2351.,  2540.,  1600.,
      1728.,  1856.,  1984.,  2589.,  2778.,  2967.,  3156.,  4512.,  4800.,
      5088.,  5376.,  4665.,  4962.,  5259.,  5556.,  4818.,  5124.,  5430.,
      5736.,  3687.,  3894.,  4101.,  4308.,  3039.,  3258.,  3477.,  3696.,
      5277.,  5610.,  5943.,  6276.,  5430.,  5772.,  6114.,  6456.,  5583.,
      5934.,  6285.,  6636.,  4257.,  4494.,  4731.,  4968.,  3489.,  3738.,
      3987.,  4236.,  6042.,  6420.,  6798.,  7176.,  6195.,  6582.,  6969.,
      7356.,  6348.,  6744.,  7140.,  7536.,  4827.,  5094.,  5361.,  5628.,
      3632.,  3808.,  3984.,  4160.,  6035.,  6302.,  6569.,  6836.,  6173.,
      6446.,  6719.,  6992.,  6311.,  6590.,  6869.,  7148.,  4636.,  4824.,
      5012.,  5200.,  1880.,  2096.,  2312.,  2528.,  3491.,  3818.,  4145.,
      4472.,  3557.,  3890.,  4223.,  4556.,  3623.,  3962.,  4301.,  4640.,
      2900.,  3128.,  3356.,  3584.,  4839.,  5178.,  5517.,  5856.,  8337.,
      8850.,  9363.,  9876.,  8490.,  9012.,  9534.,  10056., 8643.,  9174.,
      9705.,  10236., 6537.,  6894.,  7251.,  7608.,  5289.,  5658.,  6027.,
      6396.,  9102.,  9660.,  10218., 10776., 9255.,  9822.,  10389., 10956.,
      9408.,  9984.,  10560., 11136., 7107.,  7494.,  7881.,  8268.,  5739.,
      6138.,  6537.,  6936.,  9867.,  10470., 11073., 11676., 10020., 10632.,
      11244., 11856., 10173., 10794., 11415., 12036., 7677.,  8094.,  8511.,
      8928.,  5732.,  6008.,  6284.,  6560.,  9485.,  9902.,  10319., 10736.,
      9623.,  10046., 10469., 10892., 9761.,  10190., 10619., 11048., 7136.,
      7424.,  7712.,  8000.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    2.,    3.,    4.,    7.,    10.,   13.,   16.,   22.,   28.,
      34.,   40.,   33.,   38.,   43.,   48.,   27.,   30.,   33.,   36.,
      17.,   22.,   27.,   32.,   68.,   80.,   92.,   104.,  161.,  182.,
      203.,  224.,  168.,  184.,  200.,  216.,  117.,  126.,  135.,  144.,
      84.,   96.,   108.,  120.,  255.,  282.,  309.,  336.,  525.,  570.,
      615.,  660.,  477.,  510.,  543.,  576.,  306.,  324.,  342.,  360.,
      191.,  202.,  213.,  224.,  464.,  488.,  512.,  536.,  827.,  866.,
      905.,  944.,  660.,  688.,  716.,  744.,  387.,  402.,  417.,  432.,
      175.,  182.,  189.,  196.,  403.,  418.,  433.,  448.,  688.,  712.,
      736.,  760.,  525.,  542.,  559.,  576.,  297.,  306.,  315.,  324.,
      10.,   20.,   30.,   40.,   61.,   82.,   103.,  124.,  157.,  190.,
      223.,  256.,  159.,  182.,  205.,  228.,  108.,  120.,  132.,  144.,
      143.,  166.,  189.,  212.,  392.,  440.,  488.,  536.,  755.,  830.,
      905.,  980.,  636.,  688.,  740.,  792.,  387.,  414.,  441.,  468.,
      435.,  474.,  513.,  552.,  1065., 1146., 1227., 1308., 1902., 2028.,
      2154., 2280., 1503., 1590., 1677., 1764., 873.,  918.,  963.,  1008.,
      533.,  562.,  591.,  620.,  1220., 1280., 1340., 1400., 2069., 2162.,
      2255., 2348., 1560., 1624., 1688., 1752., 873.,  906.,  939.,  972.,
      400.,  416.,  432.,  448.,  889.,  922.,  955.,  988.,  1471., 1522.,
      1573., 1624., 1083., 1118., 1153., 1188., 594.,  612.,  630.,  648.,
      19.,   38.,   57.,   76.,   115.,  154.,  193.,  232.,  292.,  352.,
      412.,  472.,  285.,  326.,  367.,  408.,  189.,  210.,  231.,  252.,
      269.,  310.,  351.,  392.,  716.,  800.,  884.,  968.,  1349., 1478.,
      1607., 1736., 1104., 1192., 1280., 1368., 657.,  702.,  747.,  792.,
      786.,  852.,  918.,  984.,  1875., 2010., 2145., 2280., 3279., 3486.,
      3693., 3900., 2529., 2670., 2811., 2952., 1440., 1512., 1584., 1656.,
      875.,  922.,  969.,  1016., 1976., 2072., 2168., 2264., 3311., 3458.,
      3605., 3752., 2460., 2560., 2660., 2760., 1359., 1410., 1461., 1512.,
      625.,  650.,  675.,  700.,  1375., 1426., 1477., 1528., 2254., 2332.,
      2410., 2488., 1641., 1694., 1747., 1800., 891.,  918.,  945.,  972.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      540.,   660.,   780.,   900.,   1348.,  1552.,  1756.,  1960.,  1864.,
      2116.,  2368.,  2620.,  2380.,  2680.,  2980.,  3280.,  2244.,  2460.,
      2676.,  2892.,  2460.,  2760.,  3060.,  3360.,  5073.,  5559.,  6045.,
      6531.,  6279.,  6837.,  7395.,  7953.,  7485.,  8115.,  8745.,  9375.,
      6360.,  6804.,  7248.,  7692.,  6000.,  6540.,  7080.,  7620.,  11103.,
      11949., 12795., 13641., 12309., 13227., 14145., 15063., 13515., 14505.,
      15495., 16485., 10860., 11544., 12228., 12912., 9540.,  10320., 11100.,
      11880., 17133., 18339., 19545., 20751., 18339., 19617., 20895., 22173.,
      19545., 20895., 22245., 23595., 15360., 16284., 17208., 18132., 11940.,
      12540., 13140., 13740., 20176., 21100., 22024., 22948., 21268., 22240.,
      23212., 24184., 22360., 23380., 24400., 25420., 16716., 17412., 18108.,
      18804., 7540.,  8460.,  9380.,  10300., 14248., 15652., 17056., 18460.,
      14764., 16216., 17668., 19120., 15280., 16780., 18280., 19780., 12444.,
      13460., 14476., 15492., 20160., 21660., 23160., 24660., 35223., 37509.,
      39795., 42081., 36429., 38787., 41145., 43503., 37635., 40065., 42495.,
      44925., 28860., 30504., 32148., 33792., 23700., 25440., 27180., 28920.,
      41253., 43899., 46545., 49191., 42459., 45177., 47895., 50613., 43665.,
      46455., 49245., 52035., 33360., 35244., 37128., 39012., 27240., 29220.,
      31200., 33180., 47283., 50289., 53295., 56301., 48489., 51567., 54645.,
      57723., 49695., 52845., 55995., 59145., 37860., 39984., 42108., 44232.,
      28540., 29940., 31340., 32740., 47476., 49600., 51724., 53848., 48568.,
      50740., 52912., 55084., 49660., 51880., 54100., 56320., 36516., 38012.,
      39508., 41004., 14540., 16260., 17980., 19700., 27148., 29752., 32356.,
      34960., 27664., 30316., 32968., 35620., 28180., 30880., 33580., 36280.,
      22644., 24460., 26276., 28092., 37860., 40560., 43260., 45960., 65373.,
      69459., 73545., 77631., 66579., 70737., 74895., 79053., 67785., 72015.,
      76245., 80475., 51360., 54204., 57048., 59892., 41400., 44340., 47280.,
      50220., 71403., 75849., 80295., 84741., 72609., 77127., 81645., 86163.,
      73815., 78405., 82995., 87585., 55860., 58944., 62028., 65112., 44940.,
      48120., 51300., 54480., 77433., 82239., 87045., 91851., 78639., 83517.,
      88395., 93273., 79845., 84795., 89745., 94695., 60360., 63684., 67008.,
      70332., 45140., 47340., 49540., 51740., 74776., 78100., 81424., 84748.,
      75868., 79240., 82612., 85984., 76960., 80380., 83800., 87220., 56316.,
      58612., 60908., 63204.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,     11.,    17.,    23.,    40.,    60.,    80.,    100.,   137.,
      179.,   221.,   263.,   228.,   264.,   300.,   336.,   193.,   215.,
      237.,   259.,   100.,   136.,   172.,   208.,   452.,   540.,   628.,
      716.,   1120.,  1276.,  1432.,  1588.,  1212.,  1332.,  1452.,  1572.,
      860.,   928.,   996.,   1064.,  573.,   663.,   753.,   843.,   1812.,
      2016.,  2220.,  2424.,  3813.,  4155.,  4497.,  4839.,  3528.,  3780.,
      4032.,  4284.,  2289.,  2427.,  2565.,  2703.,  1432.,  1516.,  1600.,
      1684.,  3500.,  3684.,  3868.,  4052.,  6268.,  6568.,  6868.,  7168.,
      5028.,  5244.,  5460.,  5676.,  2960.,  3076.,  3192.,  3308.,  1337.,
      1391.,  1445.,  1499.,  3088.,  3204.,  3320.,  3436.,  5285.,  5471.,
      5657.,  5843.,  4044.,  4176.,  4308.,  4440.,  2293.,  2363.,  2433.,
      2503.,  59.,    137.,   215.,   293.,   436.,   600.,   764.,   928.,
      1163.,  1421.,  1679.,  1937.,  1200.,  1380.,  1560.,  1740.,  823.,
      917.,   1011.,  1105.,  1072.,  1252.,  1432.,  1612.,  2972.,  3348.,
      3724.,  4100.,  5764.,  6352.,  6940.,  7528.,  4884.,  5292.,  5700.,
      6108.,  2984.,  3196.,  3408.,  3620.,  3327.,  3633.,  3939.,  4245.,
      8184.,  8820.,  9456.,  10092., 14667., 15657., 16647., 17637., 11628.,
      12312., 12996., 13680., 6771.,  7125.,  7479.,  7833.,  4132.,  4360.,
      4588.,  4816.,  9476.,  9948.,  10420., 10892., 16096., 16828., 17560.,
      18292., 12156., 12660., 13164., 13668., 6812.,  7072.,  7332.,  7592.,
      3119.,  3245.,  3371.,  3497.,  6940.,  7200.,  7460.,  7720.,  11495.,
      11897., 12299., 12701., 8472.,  8748.,  9024.,  9300.,  4651.,  4793.,
      4935.,  5077.,  113.,   263.,   413.,   563.,   832.,   1140.,  1448.,
      1756.,  2189.,  2663.,  3137.,  3611.,  2172.,  2496.,  2820.,  3144.,
      1453.,  1619.,  1785.,  1951.,  2044.,  2368.,  2692.,  3016.,  5492.,
      6156.,  6820.,  7484.,  10408., 11428., 12448., 13468., 8556.,  9252.,
      9948.,  10644., 5108.,  5464.,  5820.,  6176.,  6081.,  6603.,  7125.,
      7647.,  14556., 15624., 16692., 17760., 25521., 27159., 28797., 30435.,
      19728., 20844., 21960., 23076., 11253., 11823., 12393., 12963., 6832.,
      7204.,  7576.,  7948.,  15452., 16212., 16972., 17732., 25924., 27088.,
      28252., 29416., 19284., 20076., 20868., 21660., 10664., 11068., 11472.,
      11876., 4901.,  5099.,  5297.,  5495.,  10792., 11196., 11600., 12004.,
      17705., 18323., 18941., 19559., 12900., 13320., 13740., 14160., 7009.,
      7223.,  7437.,  7651.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3928.,   4856.,   5784.,   6712.,   10076.,  11660.,  13244.,  14828.,
      14156.,  16124.,  18092.,  20060.,  18236.,  20588.,  22940.,  25292.,
      17336.,  19032.,  20728.,  22424.,  18684.,  21036.,  23388.,  25740.,
      38910.,  42726.,  46542.,  50358.,  48486.,  52878.,  57270.,  61662.,
      58062.,  63030.,  67998.,  72966.,  49548.,  53052.,  56556.,  60060.,
      46764.,  51036.,  55308.,  59580.,  86790.,  93486.,  100182., 106878.,
      96366.,  103638., 110910., 118182., 105942., 113790., 121638., 129486.,
      85308.,  90732.,  96156.,  101580., 74844.,  81036.,  87228.,  93420.,
      134670., 144246., 153822., 163398., 144246., 154398., 164550., 174702.,
      153822., 164550., 175278., 186006., 121068., 128412., 135756., 143100.,
      94264.,  99032.,  103800., 108568., 159404., 166748., 174092., 181436.,
      168092., 175820., 183548., 191276., 176780., 184892., 193004., 201116.,
      132248., 137784., 143320., 148856., 59128.,  66456.,  73784.,  81112.,
      112076., 123260., 134444., 145628., 116156., 127724., 139292., 150860.,
      120236., 132188., 144140., 156092., 98136.,  106232., 114328., 122424.,
      159084., 171036., 182988., 194940., 278310., 296526., 314742., 332958.,
      287886., 306678., 325470., 344262., 297462., 316830., 336198., 355566.,
      228348., 241452., 254556., 267660., 187164., 201036., 214908., 228780.,
      326190., 347286., 368382., 389478., 335766., 357438., 379110., 400782.,
      345342., 367590., 389838., 412086., 264108., 279132., 294156., 309180.,
      215244., 231036., 246828., 262620., 374070., 398046., 422022., 445998.,
      383646., 408198., 432750., 457302., 393222., 418350., 443478., 468606.,
      299868., 316812., 333756., 350700., 226264., 237432., 248600., 259768.,
      376604., 393548., 410492., 427436., 385292., 402620., 419948., 437276.,
      393980., 411692., 429404., 447116., 289848., 301784., 313720., 325656.,
      114328., 128056., 141784., 155512., 214076., 234860., 255644., 276428.,
      218156., 239324., 260492., 281660., 222236., 243788., 265340., 286892.,
      178936., 193432., 207928., 222424., 299484., 321036., 342588., 364140.,
      517710., 550326., 582942., 615558., 527286., 560478., 593670., 626862.,
      536862., 570630., 604398., 638166., 407148., 429852., 452556., 475260.,
      327564., 351036., 374508., 397980., 565590., 601086., 636582., 672078.,
      575166., 611238., 647310., 683382., 584742., 621390., 658038., 694686.,
      442908., 467532., 492156., 516780., 355644., 381036., 406428., 431820.,
      613470., 651846., 690222., 728598., 623046., 661998., 700950., 739902.,
      632622., 672150., 711678., 751206., 478668., 505212., 531756., 558300.,
      358264., 375832., 393400., 410968., 593804., 620348., 646892., 673436.,
      602492., 629420., 656348., 683276., 611180., 638492., 665804., 693116.,
      447448., 465784., 484120., 502456.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,     70.,     110.,    150.,    260.,    404.,    548.,    692.,
      946.,    1258.,   1570.,   1882.,   1684.,   1956.,   2228.,   2500.,
      1454.,   1622.,   1790.,   1958.,   660.,    932.,    1204.,   1476.,
      3256.,   3928.,   4600.,   5272.,   8300.,   9500.,   10700.,  11900.,
      9176.,   10104.,  11032.,  11960.,  6580.,   7108.,   7636.,   8164.,
      4194.,   4890.,   5586.,   6282.,   13596.,  15180.,  16764.,  18348.,
      28974.,  31638.,  34302.,  36966.,  27084.,  29052.,  31020.,  32988.,
      17682.,  18762.,  19842.,  20922.,  11076.,  11732.,  12388.,  13044.,
      27160.,  28600.,  30040.,  31480.,  48764.,  51116.,  53468.,  55820.,
      39224.,  40920.,  42616.,  44312.,  23140.,  24052.,  24964.,  25876.,
      10446.,  10870.,  11294.,  11718.,  24164.,  25076.,  25988.,  26900.,
      41410.,  42874.,  44338.,  45802.,  31732.,  32772.,  33812.,  34852.,
      18014.,  18566.,  19118.,  19670.,  390.,    1006.,   1622.,   2238.,
      3284.,   4580.,   5876.,   7172.,   8938.,   10978.,  13018.,  15058.,
      9316.,   10740.,  12164.,  13588.,  6422.,   7166.,   7910.,   8654.,
      8292.,   9716.,   11140.,  12564.,  23128.,  26104.,  29080.,  32056.,
      45020.,  49676.,  54332.,  58988.,  38264.,  41496.,  44728.,  47960.,
      23428.,  25108.,  26788.,  28468.,  26010.,  28434.,  30858.,  33282.,
      64140.,  69180.,  74220.,  79260.,  115158., 123006., 130854., 138702.,
      91452.,  96876.,  102300., 107724., 53322.,  56130.,  58938.,  61746.,
      32532.,  34340.,  36148.,  37956.,  74680.,  78424.,  82168.,  85912.,
      126956., 132764., 138572., 144380., 95960.,  99960.,  103960., 107960.,
      53812.,  55876.,  57940.,  60004.,  24630.,  25630.,  26630.,  27630.,
      54836.,  56900.,  58964.,  61028.,  90874.,  94066.,  97258.,  100450.,
      67012.,  69204.,  71396.,  73588.,  36806.,  37934.,  39062.,  40190.,
      750.,    1942.,   3134.,   4326.,   6308.,   8756.,   11204.,  13652.,
      16930.,  20698.,  24466.,  28234.,  16948.,  19524.,  22100.,  24676.,
      11390.,  12710.,  14030.,  15350.,  15924.,  18500.,  21076.,  23652.,
      43000.,  48280.,  53560.,  58840.,  81740.,  89852.,  97964.,  106076.,
      67352.,  72888.,  78424.,  83960.,  40276.,  43108.,  45940.,  48772.,
      47826.,  51978.,  56130.,  60282.,  114684., 123180., 131676., 140172.,
      201342., 214374., 227406., 240438., 155820., 164700., 173580., 182460.,
      88962.,  93498.,  98034.,  102570., 53988.,  56948.,  59908.,  62868.,
      122200., 128248., 134296., 140344., 205148., 214412., 223676., 232940.,
      152696., 159000., 165304., 171608., 84484.,  87700.,  90916.,  94132.,
      38814.,  40390.,  41966.,  43542.,  85508.,  88724.,  91940.,  95156.,
      140338., 145258., 150178., 155098., 102292., 105636., 108980., 112324.,
      55598.,  57302.,  59006.,  60710.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      35.,   74.,   95.,   116.,  137.,  117.,  129.,  246.,  291.,  336.,
      381.,  306.,  291.,  516.,  561.,  606.,  651.,  504.,  453.,  786.,
      831.,  876.,  921.,  702.,  521.,  866.,  905.,  944.,  983.,  723.,
      395.,  704.,  725.,  746.,  767.,  597.,  939.,  1596., 1641., 1686.,
      1731., 1296., 1101., 1866., 1911., 1956., 2001., 1494., 1263., 2136.,
      2181., 2226., 2271., 1692., 1241., 2036., 2075., 2114., 2153., 1563.,
      755.,  1334., 1355., 1376., 1397., 1077., 1749., 2946., 2991., 3036.,
      3081., 2286., 1911., 3216., 3261., 3306., 3351., 2484., 2073., 3486.,
      3531., 3576., 3621., 2682., 1961., 3206., 3245., 3284., 3323., 2403.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    4.,    10.,  16.,  17.,   12.,   9.,   29.,  62.,  83.,
      75.,   48.,   36.,  99.,  192.,  237.,  198., 120., 71.,  167.,
      290.,  329.,  253., 144., 63.,   142.,  238., 262., 195., 108.,
      13.,   40.,   82.,  88.,  77.,   48.,   69.,  173., 314., 335.,
      267.,  156.,  180., 423., 732.,  777.,  594., 336., 203., 455.,
      758.,  797.,  589., 324., 147.,  322.,  526., 550., 399., 216.,
      25.,   76.,   154., 160., 137.,  84.,   129., 317., 566., 587.,
      459.,  264.,  324., 747., 1272., 1317., 990., 552., 335., 743.,
      1226., 1265., 925., 504., 231.,  502.,  814., 838., 603., 324.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      224.,   496.,   652.,   808.,   964.,   840.,   894.,   1743.,  2085.,
      2427.,  2769.,  2250.,  2118.,  3795.,  4137.,  4479.,  4821.,  3762.,
      3342.,  5847.,  6189.,  6531.,  6873.,  5274.,  3944.,  6580.,  6880.,
      7180.,  7480.,  5520.,  2864.,  5176.,  5332.,  5488.,  5644.,  4440.,
      7014.,  12003., 12345., 12687., 13029., 9810.,  8238.,  14055., 14397.,
      14739., 15081., 11322., 9462.,  16107., 16449., 16791., 17133., 12834.,
      9464.,  15580., 15880., 16180., 16480., 12000., 5504.,  9856.,  10012.,
      10168., 10324., 8040.,  13134., 22263., 22605., 22947., 23289., 17370.,
      14358., 24315., 24657., 24999., 25341., 18882., 15582., 26367., 26709.,
      27051., 27393., 20394., 14984., 24580., 24880., 25180., 25480., 18480.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    22.,   59.,   101.,  114.,  83.,   52.,   184.,  412.,  568.,
      528.,  344.,  237.,  678.,  1347., 1689., 1434., 879.,  520.,  1232.,
      2152., 2452., 1896., 1084., 473.,  1070., 1799., 1985., 1482., 823.,
      77.,   262.,  563.,  605.,  546.,  347.,  484.,  1240., 2284., 2440.,
      1968., 1160., 1317., 3126., 5451., 5793., 4458., 2535., 1528., 3440.,
      5752., 6052., 4488., 2476., 1121., 2462., 4031., 4217., 3066., 1663.,
      149.,  502.,  1067., 1109., 978.,  611.,  916.,  2296., 4156., 4312.,
      3408., 1976., 2397., 5574., 9555., 9897., 7482., 4191., 2536., 5648.,
      9352., 9652., 7080., 3868., 1769., 3854., 6263., 6449., 4650., 2503.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1576.,   3596.,   4796.,   5996.,   7196.,   6344.,   6612.,   13062.,
      15726.,  18390.,  21054.,  17220.,  16116.,  29046.,  31710.,  34374.,
      37038.,  29028.,  25620.,  45030.,  47694.,  50358.,  53022.,  40836.,
      30664.,  51260.,  53612.,  55964.,  58316.,  43112.,  21736.,  39596.,
      40796.,  41996.,  43196.,  34184.,  54132.,  92982.,  95646.,  98310.,
      100974., 76260.,  63636.,  108966., 111630., 114294., 116958., 88068.,
      73140.,  124950., 127614., 130278., 132942., 99876.,  73864.,  121820.,
      124172., 126524., 128876., 93992.,  41896.,  75596.,  76796.,  77996.,
      79196.,  62024.,  101652., 172902., 175566., 178230., 180894., 135300.,
      111156., 188886., 191550., 194214., 196878., 147108., 120660., 204870.,
      207534., 210198., 212862., 158916., 117064., 192380., 194732., 197084.,
      199436., 144872.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    140.,   394.,   706.,   828.,   614.,   340.,   1288.,  2972.,
      4172.,  3944.,  2596.,  1698.,  4980.,  10038., 12702., 10884., 6714.,
      3972.,  9448.,  16556., 18908., 14664., 8404.,  3662.,  8300.,  13978.,
      15442., 11548., 6422.,  510.,   1868.,  4138.,  4450.,  4092.,  2630.,
      3604.,  9352.,  17372., 18572., 15080., 8932.,  10050., 23988., 42006.,
      44670., 34500., 19674., 11844., 26728., 44780., 47132., 35016., 19348.,
      8750.,  19244., 31546., 33010., 24028., 13046., 990.,   3596.,  7882.,
      8194.,  7356.,  4646.,  6868.,  17416., 31772., 32972., 26216., 15268.,
      18402., 42996., 73974., 76638., 58116., 32634., 19716., 44008., 73004.,
      75356., 55368., 30292., 13838., 30188., 49114., 50578., 36508., 19670.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      52.,   70.,   118.,  148.,  154.,  190.,  190.,  232.,  226.,  274.,
      200.,  234.,  213.,  258.,  420.,  492.,  501.,  582.,  582.,  672.,
      663.,  762.,  543.,  612.,  501.,  582.,  906.,  1032., 987.,  1122.,
      1068., 1212., 1149., 1302., 903.,  1008., 789.,  906.,  1392., 1572.,
      1473., 1662., 1554., 1752., 1635., 1842., 1263., 1404., 952.,  1042.,
      1594., 1732., 1666., 1810., 1738., 1888., 1810., 1966., 1340., 1446.,
      652.,  790.,  1198., 1408., 1234., 1450., 1270., 1492., 1306., 1534.,
      1040., 1194., 1653., 1878., 2850., 3192., 2931., 3282., 3012., 3372.,
      3093., 3462., 2343., 2592., 1941., 2202., 3336., 3732., 3417., 3822.,
      3498., 3912., 3579., 4002., 2703., 2988., 2229., 2526., 3822., 4272.,
      3903., 4362., 3984., 4452., 4065., 4542., 3063., 3384., 2272., 2482.,
      3754., 4072., 3826., 4150., 3898., 4228., 3970., 4306., 2900., 3126.,
      1252., 1510., 2278., 2668., 2314., 2710., 2350., 2752., 2386., 2794.,
      1880., 2154., 3093., 3498., 5280., 5892., 5361., 5982., 5442., 6072.,
      5523., 6162., 4143., 4572., 3381., 3822., 5766., 6432., 5847., 6522.,
      5928., 6612., 6009., 6702., 4503., 4968., 3669., 4146., 6252., 6972.,
      6333., 7062., 6414., 7152., 6495., 7242., 4863., 5364., 3592., 3922.,
      5914., 6412., 5986., 6490., 6058., 6568., 6130., 6646., 4460., 4806.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    2.,    5.,    8.,    14.,   20.,   23.,   32.,   27.,   34.,
      20.,   24.,   12.,   18.,   44.,   58.,   100.,  124.,  136.,  166.,
      128.,  150.,  84.,   96.,   57.,   72.,   165.,  198.,  330.,  384.,
      411.,  474.,  351.,  396.,  216.,  240.,  128.,  142.,  304.,  334.,
      532.,  580.,  604.,  658.,  468.,  506.,  268.,  288.,  117.,  126.,
      265.,  284.,  446.,  476.,  491.,  524.,  367.,  390.,  204.,  216.,
      13.,   26.,   53.,   80.,   122.,  164.,  131.,  176.,  123.,  154.,
      80.,   96.,   108.,  138.,  284.,  346.,  532.,  628.,  568.,  670.,
      464.,  534.,  276.,  312.,  309.,  360.,  741.,  846.,  1302., 1464.,
      1383., 1554., 1071., 1188., 612.,  672.,  368.,  406.,  832.,  910.,
      1396., 1516., 1468., 1594., 1092., 1178., 604.,  648.,  273.,  294.,
      601.,  644.,  986.,  1052., 1031., 1100., 751.,  798.,  408.,  432.,
      25.,   50.,   101.,  152.,  230.,  308.,  239.,  320.,  219.,  274.,
      140.,  168.,  204.,  258.,  524.,  634.,  964.,  1132., 1000., 1174.,
      800.,  918.,  468.,  528.,  561.,  648.,  1317., 1494., 2274., 2544.,
      2355., 2634., 1791., 1980., 1008., 1104., 608.,  670.,  1360., 1486.,
      2260., 2452., 2332., 2530., 1716., 1850., 940.,  1008., 429.,  462.,
      937.,  1004., 1526., 1628., 1571., 1676., 1135., 1206., 612.,  648.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      344.,   480.,   818.,   1046.,  1094.,  1370.,  1370.,  1694.,  1646.,
      2018.,  1480.,  1744.,  1524.,  1872.,  3063.,  3621.,  3693.,  4323.,
      4323.,  5025.,  4953.,  5727.,  4092.,  4632.,  3756.,  4392.,  6843.,
      7833.,  7473.,  8535.,  8103.,  9237.,  8733.,  9939.,  6900.,  7728.,
      5988.,  6912.,  10623., 12045., 11253., 12747., 11883., 13449., 12513.,
      14151., 9708.,  10824., 7352.,  8064.,  12338., 13430., 12902., 14042.,
      13466., 14654., 14030., 15266., 10408., 11248., 4904.,  6000.,  9098.,
      10766., 9374.,  11090., 9650.,  11414., 9926.,  11738., 7960.,  9184.,
      12684., 14472., 21963., 24681., 22593., 25383., 23223., 26085., 23853.,
      26787., 18132., 20112., 14916., 16992., 25743., 28893., 26373., 29595.,
      27003., 30297., 27633., 30999., 20940., 23208., 17148., 19512., 29523.,
      33105., 30153., 33807., 30783., 34509., 31413., 35211., 23748., 26304.,
      17672., 19344., 29258., 31790., 29822., 32402., 30386., 33014., 30950.,
      33626., 22648., 24448., 9464.,  11520., 17378., 20486., 17654., 20810.,
      17930., 21134., 18206., 21458., 14440., 16624., 23844., 27072., 40863.,
      45741., 41493., 46443., 42123., 47145., 42753., 47847., 32172., 35592.,
      26076., 29592., 44643., 49953., 45273., 50655., 45903., 51357., 46533.,
      52059., 34980., 38688., 28308., 32112., 48423., 54165., 49053., 54867.,
      49683., 55569., 50313., 56271., 37788., 41784., 27992., 30624., 46178.,
      50150., 46742., 50762., 47306., 51374., 47870., 51986., 34888., 37648.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,     11.,    28.,    48.,    85.,    127.,   151.,   217.,   188.,
      240.,   143.,   173.,   70.,    114.,   288.,   392.,   686.,   866.,
      962.,   1190.,  928.,   1096.,  618.,   710.,   387.,   501.,   1164.,
      1416.,  2379.,  2793.,  3009.,  3495.,  2604.,  2952.,  1617.,  1803.,
      958.,   1066.,  2288.,  2520.,  4022.,  4394.,  4586.,  5006.,  3568.,
      3864.,  2050.,  2206.,  893.,   963.,   2028.,  2176.,  3421.,  3655.,
      3775.,  4033.,  2828.,  3008.,  1575.,  1669.,  77.,    179.,   364.,
      576.,   877.,   1207.,  943.,   1297.,  908.,   1152.,  599.,   725.,
      790.,   1026.,  2112.,  2600.,  3998.,  4754.,  4274.,  5078.,  3520.,
      4072.,  2106.,  2390.,  2331.,  2733.,  5628.,  6456.,  9939.,  11217.,
      10569., 11919., 8220.,  9144.,  4713.,  5187.,  2830.,  3130.,  6416.,
      7032.,  10790., 11738., 11354., 12350., 8464.,  9144.,  4690.,  5038.,
      2117.,  2283.,  4668.,  5008.,  7669.,  8191.,  8023.,  8569.,  5852.,
      6224.,  3183.,  3373.,  149.,   347.,   700.,   1104.,  1669.,  2287.,
      1735.,  2377.,  1628.,  2064.,  1055.,  1277.,  1510.,  1938.,  3936.,
      4808.,  7310.,  8642.,  7586.,  8966.,  6112.,  7048.,  3594.,  4070.,
      4275.,  4965.,  10092., 11496., 17499., 19641., 18129., 20343., 13836.,
      15336., 7809.,  8571.,  4702.,  5194.,  10544., 11544., 17558., 19082.,
      18122., 19694., 13360., 14424., 7330.,  7870.,  3341.,  3603.,  7308.,
      7840.,  11917., 12727., 12271., 13105., 8876.,  9440.,  4791.,  5077.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2472.,   3528.,   6052.,   7828.,   8212.,   10372.,  10372.,  12916.,
      12532.,  15460.,  11368.,  13448.,  11484.,  14220.,  23334.,  27726.,
      28302.,  33270.,  33270.,  38814.,  38238.,  44358.,  31740.,  36012.,
      29052.,  34092.,  53142.,  60990.,  58110.,  66534.,  63078.,  72078.,
      68046.,  77622.,  53916.,  60492.,  46620.,  53964.,  82950.,  94254.,
      87918.,  99798.,  92886.,  105342., 97854.,  110886., 76092.,  84972.,
      57768.,  63432.,  97060.,  105748., 101524., 110596., 105988., 115444.,
      110452., 120292., 82024.,  88712.,  37992.,  46728.,  70852.,  84148.,
      73012.,  86692.,  75172.,  89236.,  77332.,  91780.,  62248.,  72008.,
      99324.,  113580., 172374., 194046., 177342., 199590., 182310., 205134.,
      187278., 210678., 142620., 158412., 116892., 133452., 202182., 227310.,
      207150., 232854., 212118., 238398., 217086., 243942., 164796., 182892.,
      134460., 153324., 231990., 260574., 236958., 266118., 241926., 271662.,
      246894., 277206., 186972., 207372., 139368., 152712., 230980., 251188.,
      235444., 256036., 239908., 260884., 244372., 265732., 178984., 193352.,
      73512.,  89928.,  135652., 160468., 137812., 163012., 139972., 165556.,
      142132., 168100., 113128., 130568., 187164., 212940., 321414., 360366.,
      326382., 365910., 331350., 371454., 336318., 376998., 253500., 280812.,
      204732., 232812., 351222., 393630., 356190., 399174., 361158., 404718.,
      366126., 410262., 275676., 305292., 222300., 252684., 381030., 426894.,
      385998., 432438., 390966., 437982., 395934., 443526., 297852., 329772.,
      220968., 241992., 364900., 396628., 369364., 401476., 373828., 406324.,
      378292., 411172., 275944., 297992.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,     70.,     180.,    324.,    578.,    890.,    1082.,   1586.,
      1396.,   1796.,   1078.,   1310.,   460.,    796.,    2056.,   2856.,
      5044.,   6436.,   7204.,   8980.,   7048.,   8360.,   4732.,   5452.,
      2826.,   3714.,   8700.,   10668.,  18006.,  21246.,  22974.,  26790.,
      20028.,  22764.,  12498.,  13962.,  7404.,   8252.,   17736.,  19560.,
      31252.,  34180.,  35716.,  39028.,  27848.,  30184.,  16028.,  17260.,
      6974.,   7526.,   15860.,  17028.,  26786.,  28634.,  29594.,  31634.,
      22196.,  23620.,  12374.,  13118.,  510.,    1318.,   2676.,   4356.,
      6626.,   9242.,   7130.,   9938.,   6964.,   8900.,   4630.,   5630.,
      6028.,   7900.,   16264.,  20136.,  30964.,  36964.,  33124.,  39508.,
      27400.,  31784.,  16444.,  18700.,  18090.,  21282.,  43836.,  50412.,
      77622.,  87774.,  82590.,  93318.,  64380.,  71724.,  36978.,  40746.,
      22188.,  24572.,  50376.,  55272.,  84820.,  92356.,  89284.,  97204.,
      66632.,  72040.,  36956.,  39724.,  16670.,  17990.,  36788.,  39492.,
      60482.,  64634.,  63290.,  67634.,  46196.,  49156.,  25142.,  26654.,
      990.,    2566.,   5172.,   8388.,   12674.,  17594.,  13178.,  18290.,
      12532.,  16004.,  8182.,   9950.,   11596.,  15004.,  30472.,  37416.,
      56884.,  67492.,  59044.,  70036.,  47752.,  55208.,  28156.,  31948.,
      33354.,  38850.,  78972.,  90156.,  137238., 154302., 142206., 159846.,
      108732., 120684., 61458.,  67530.,  36972.,  40892.,  83016.,  90984.,
      138388., 150532., 142852., 155380., 105416., 113896., 57884.,  62188.,
      26366.,  28454.,  57716.,  61956.,  94178.,  100634., 96986.,  103634.,
      70196.,  74692.,  37910.,  40190.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      86.,    104.,   122.,   140.,   206.,   236.,   266.,   296.,   272.,
      308.,   344.,   380.,   338.,   380.,   422.,   464.,   404.,   452.,
      500.,   548.,   366.,   400.,   434.,   468.,   381.,   426.,   471.,
      516.,   768.,   840.,   912.,   984.,   921.,   1002.,  1083.,  1164.,
      1074.,  1164.,  1254.,  1344.,  1227.,  1326.,  1425.,  1524.,  1017.,
      1086.,  1155.,  1224.,  921.,   1002.,  1083.,  1164.,  1686.,  1812.,
      1938.,  2064.,  1839.,  1974.,  2109.,  2244.,  1992.,  2136.,  2280.,
      2424.,  2145.,  2298.,  2451.,  2604.,  1701.,  1806.,  1911.,  2016.,
      1461.,  1578.,  1695.,  1812.,  2604.,  2784.,  2964.,  3144.,  2757.,
      2946.,  3135.,  3324.,  2910.,  3108.,  3306.,  3504.,  3063.,  3270.,
      3477.,  3684.,  2385.,  2526.,  2667.,  2808.,  1814.,  1904.,  1994.,
      2084.,  3050.,  3188.,  3326.,  3464.,  3188.,  3332.,  3476.,  3620.,
      3326.,  3476.,  3626.,  3776.,  3464.,  3620.,  3776.,  3932.,  2574.,
      2680.,  2786.,  2892.,  1166.,  1304.,  1442.,  1580.,  2186.,  2396.,
      2606.,  2816.,  2252.,  2468.,  2684.,  2900.,  2318.,  2540.,  2762.,
      2984.,  2384.,  2612.,  2840.,  3068.,  1926.,  2080.,  2234.,  2388.,
      3081.,  3306.,  3531.,  3756.,  5358.,  5700.,  6042.,  6384.,  5511.,
      5862.,  6213.,  6564.,  5664.,  6024.,  6384.,  6744.,  5817.,  6186.,
      6555.,  6924.,  4437.,  4686.,  4935.,  5184.,  3621.,  3882.,  4143.,
      4404.,  6276.,  6672.,  7068.,  7464.,  6429.,  6834.,  7239.,  7644.,
      6582.,  6996.,  7410.,  7824.,  6735.,  7158.,  7581.,  8004.,  5121.,
      5406.,  5691.,  5976.,  4161.,  4458.,  4755.,  5052.,  7194.,  7644.,
      8094.,  8544.,  7347.,  7806.,  8265.,  8724.,  7500.,  7968.,  8436.,
      8904.,  7653.,  8130.,  8607.,  9084.,  5805.,  6126.,  6447.,  6768.,
      4334.,  4544.,  4754.,  4964.,  7190.,  7508.,  7826.,  8144.,  7328.,
      7652.,  7976.,  8300.,  7466.,  7796.,  8126.,  8456.,  7604.,  7940.,
      8276.,  8612.,  5574.,  5800.,  6026.,  6252.,  2246.,  2504.,  2762.,
      3020.,  4166.,  4556.,  4946.,  5336.,  4232.,  4628.,  5024.,  5420.,
      4298.,  4700.,  5102.,  5504.,  4364.,  4772.,  5180.,  5588.,  3486.,
      3760.,  4034.,  4308.,  5781.,  6186.,  6591.,  6996.,  9948.,  10560.,
      11172., 11784., 10101., 10722., 11343., 11964., 10254., 10884., 11514.,
      12144., 10407., 11046., 11685., 12324., 7857.,  8286.,  8715.,  9144.,
      6321.,  6762.,  7203.,  7644.,  10866., 11532., 12198., 12864., 11019.,
      11694., 12369., 13044., 11172., 11856., 12540., 13224., 11325., 12018.,
      12711., 13404., 8541.,  9006.,  9471.,  9936.,  6861.,  7338.,  7815.,
      8292.,  11784., 12504., 13224., 13944., 11937., 12666., 13395., 14124.,
      12090., 12828., 13566., 14304., 12243., 12990., 13737., 14484., 9225.,
      9726.,  10227., 10728., 6854.,  7184.,  7514.,  7844.,  11330., 11828.,
      12326., 12824., 11468., 11972., 12476., 12980., 11606., 12116., 12626.,
      13136., 11744., 12260., 12776., 13292., 8574.,  8920.,  9266.,  9612.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    2.,    3.,    4.,    7.,    10.,   13.,   16.,   22.,   28.,
      34.,   40.,   37.,   46.,   55.,   64.,   47.,   54.,   61.,   68.,
      36.,   40.,   44.,   48.,   18.,   24.,   30.,   36.,   74.,   88.,
      102.,  116.,  176.,  200.,  224.,  248.,  242.,  272.,  302.,  332.,
      234.,  256.,  278.,  300.,  156.,  168.,  180.,  192.,  99.,   114.,
      129.,  144.,  297.,  330.,  363.,  396.,  606.,  660.,  714.,  768.,
      759.,  822.,  885.,  948.,  657.,  702.,  747.,  792.,  408.,  432.,
      456.,  480.,  242.,  256.,  270.,  284.,  578.,  608.,  638.,  668.,
      1016., 1064., 1112., 1160., 1154., 1208., 1262., 1316., 898.,  936.,
      974.,  1012., 516.,  536.,  556.,  576.,  225.,  234.,  243.,  252.,
      511.,  530.,  549.,  568.,  862.,  892.,  922.,  952.,  949.,  982.,
      1015., 1048., 711.,  734.,  757.,  780.,  396.,  408.,  420.,  432.,
      13.,   26.,   39.,   52.,   79.,   106.,  133.,  160.,  202.,  244.,
      286.,  328.,  217.,  262.,  307.,  352.,  215.,  246.,  277.,  308.,
      144.,  160.,  176.,  192.,  186.,  216.,  246.,  276.,  506.,  568.,
      630.,  692.,  968.,  1064., 1160., 1256., 1034., 1136., 1238., 1340.,
      858.,  928.,  998.,  1068., 516.,  552.,  588.,  624.,  567.,  618.,
      669.,  720.,  1377., 1482., 1587., 1692., 2442., 2604., 2766., 2928.,
      2595., 2766., 2937., 3108., 2025., 2142., 2259., 2376., 1164., 1224.,
      1284., 1344., 698.,  736.,  774.,  812.,  1586., 1664., 1742., 1820.,
      2672., 2792., 2912., 3032., 2810., 2936., 3062., 3188., 2098., 2184.,
      2270., 2356., 1164., 1208., 1252., 1296., 525.,  546.,  567.,  588.,
      1159., 1202., 1245., 1288., 1906., 1972., 2038., 2104., 1993., 2062.,
      2131., 2200., 1455., 1502., 1549., 1596., 792.,  816.,  840.,  864.,
      25.,   50.,   75.,   100.,  151.,  202.,  253.,  304.,  382.,  460.,
      538.,  616.,  397.,  478.,  559.,  640.,  383.,  438.,  493.,  548.,
      252.,  280.,  308.,  336.,  354.,  408.,  462.,  516.,  938.,  1048.,
      1158., 1268., 1760., 1928., 2096., 2264., 1826., 2000., 2174., 2348.,
      1482., 1600., 1718., 1836., 876.,  936.,  996.,  1056., 1035., 1122.,
      1209., 1296., 2457., 2634., 2811., 2988., 4278., 4548., 4818., 5088.,
      4431., 4710., 4989., 5268., 3393., 3582., 3771., 3960., 1920., 2016.,
      2112., 2208., 1154., 1216., 1278., 1340., 2594., 2720., 2846., 2972.,
      4328., 4520., 4712., 4904., 4466., 4664., 4862., 5060., 3298., 3432.,
      3566., 3700., 1812., 1880., 1948., 2016., 825.,  858.,  891.,  924.,
      1807., 1874., 1941., 2008., 2950., 3052., 3154., 3256., 3037., 3142.,
      3247., 3352., 2199., 2270., 2341., 2412., 1188., 1224., 1260., 1296.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      584.,   720.,    856.,    992.,    1462.,  1690.,   1918.,   2146.,
      1978.,  2254.,   2530.,   2806.,   2494.,  2818.,   3142.,   3466.,
      3010.,  3382.,   3754.,   4126.,   2760.,  3024.,   3288.,   3552.,
      2784.,  3132.,   3480.,   3828.,   5703.,  6261.,   6819.,   7377.,
      6909.,  7539.,   8169.,   8799.,   8115.,  8817.,   9519.,   10221.,
      9321.,  10095.,  10869.,  11643.,  7776.,  8316.,   8856.,   9396.,
      7032.,  7668.,   8304.,   8940.,   12939., 13929.,  14919.,  15909.,
      14145., 15207.,  16269.,  17331.,  15351., 16485.,  17619.,  18753.,
      16557., 17763.,  18969.,  20175.,  13176., 14004.,  14832.,  15660.,
      11280., 12204.,  13128.,  14052.,  20175., 21597.,  23019.,  24441.,
      21381., 22875.,  24369.,  25863.,  22587., 24153.,  25719.,  27285.,
      23793., 25431.,  27069.,  28707.,  18576., 19692.,  20808.,  21924.,
      14168., 14880.,  15592.,  16304.,  23854., 24946.,  26038.,  27130.,
      24946., 26086.,  27226.,  28366.,  26038., 27226.,  28414.,  29602.,
      27130., 28366.,  29602.,  30838.,  20184., 21024.,  21864.,  22704.,
      8984.,  10080.,  11176.,  12272.,  16942., 18610.,  20278.,  21946.,
      17458., 19174.,  20890.,  22606.,  17974., 19738.,  21502.,  23266.,
      18490., 20302.,  22114.,  23926.,  15000., 16224.,  17448.,  18672.,
      24024., 25812.,  27600.,  29388.,  41883., 44601.,  47319.,  50037.,
      43089., 45879.,  48669.,  51459.,  44295., 47157.,  50019.,  52881.,
      45501., 48435.,  51369.,  54303.,  34776., 36756.,  38736.,  40716.,
      28272., 30348.,  32424.,  34500.,  49119., 52269.,  55419.,  58569.,
      50325., 53547.,  56769.,  59991.,  51531., 54825.,  58119.,  61413.,
      52737., 56103.,  59469.,  62835.,  40176., 42444.,  44712.,  46980.,
      32520., 34884.,  37248.,  39612.,  56355., 59937.,  63519.,  67101.,
      57561., 61215.,  64869.,  68523.,  58767., 62493.,  66219.,  69945.,
      59973., 63771.,  67569.,  71367.,  45576., 48132.,  50688.,  53244.,
      34088., 35760.,  37432.,  39104.,  56614., 59146.,  61678.,  64210.,
      57706., 60286.,  62866.,  65446.,  58798., 61426.,  64054.,  66682.,
      59890., 62566.,  65242.,  67918.,  43944., 45744.,  47544.,  49344.,
      17384., 19440.,  21496.,  23552.,  32422., 35530.,  38638.,  41746.,
      32938., 36094.,  39250.,  42406.,  33454., 36658.,  39862.,  43066.,
      33970., 37222.,  40474.,  43726.,  27240., 29424.,  31608.,  33792.,
      45264., 48492.,  51720.,  54948.,  78063., 82941.,  87819.,  92697.,
      79269., 84219.,  89169.,  94119.,  80475., 85497.,  90519.,  95541.,
      81681., 86775.,  91869.,  96963.,  61776., 65196.,  68616.,  72036.,
      49512., 53028.,  56544.,  60060.,  85299., 90609.,  95919.,  101229.,
      86505., 91887.,  97269.,  102651., 87711., 93165.,  98619.,  104073.,
      88917., 94443.,  99969.,  105495., 67176., 70884.,  74592.,  78300.,
      53760., 57564.,  61368.,  65172.,  92535., 98277.,  104019., 109761.,
      93741., 99555.,  105369., 111183., 94947., 100833., 106719., 112605.,
      96153., 102111., 108069., 114027., 72576., 76572.,  80568.,  84564.,
      54008., 56640.,  59272.,  61904.,  89374., 93346.,  97318.,  101290.,
      90466., 94486.,  98506.,  102526., 91558., 95626.,  99694.,  103762.,
      92650., 96766.,  100882., 104998., 67704., 70464.,  73224.,  75984.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,     11.,    17.,    23.,    40.,    60.,    80.,    100.,   137.,
      179.,   221.,   263.,   251.,   317.,   383.,   449.,   336.,   388.,
      440.,   492.,   263.,   293.,   323.,   353.,   106.,   150.,   194.,
      238.,   496.,   600.,   704.,   808.,   1234.,  1414.,  1594.,  1774.,
      1750.,  1978.,  2206.,  2434.,  1728.,  1896.,  2064.,  2232.,  1166.,
      1258.,  1350.,  1442.,  687.,   801.,   915.,   1029.,  2136.,  2388.,
      2640.,  2892.,  4443.,  4857.,  5271.,  5685.,  5649.,  6135.,  6621.,
      7107.,  4944.,  5292.,  5640.,  5988.,  3093.,  3279.,  3465.,  3651.,
      1834.,  1942.,  2050.,  2158.,  4400.,  4632.,  4864.,  5096.,  7762.,
      8134.,  8506.,  8878.,  8854.,  9274.,  9694.,  10114., 6912.,  7208.,
      7504.,  7800.,  3982.,  4138.,  4294.,  4450.,  1733.,  1803.,  1873.,
      1943.,  3944.,  4092.,  4240.,  4388.,  6665.,  6899.,  7133.,  7367.,
      7355.,  7613.,  7871.,  8129.,  5520.,  5700.,  5880.,  6060.,  3079.,
      3173.,  3267.,  3361.,  77.,    179.,   281.,   383.,   568.,   780.,
      992.,   1204.,  1505.,  1835.,  2165.,  2495.,  1619.,  1973.,  2327.,
      2681.,  1632.,  1876.,  2120.,  2364.,  1103.,  1229.,  1355.,  1481.,
      1402.,  1638.,  1874.,  2110.,  3856.,  4344.,  4832.,  5320.,  7426.,
      8182.,  8938.,  9694.,  7942.,  8746.,  9550.,  10354., 6624.,  7176.,
      7728.,  8280.,  3998.,  4282.,  4566.,  4850.,  4359.,  4761.,  5163.,
      5565.,  10632., 11460., 12288., 13116., 18915., 20193., 21471., 22749.,
      20121., 21471., 22821., 24171., 15744., 16668., 17592., 18516., 9069.,
      9543.,  10017., 10491., 5434.,  5734.,  6034.,  6334.,  12368., 12984.,
      13600., 14216., 20866., 21814., 22762., 23710., 21958., 22954., 23950.,
      24946., 16416., 17096., 17776., 18456., 9118.,  9466.,  9814.,  10162.,
      4109.,  4275.,  4441.,  4607.,  9080.,  9420.,  9760.,  10100., 14945.,
      15467., 15989., 16511., 15635., 16181., 16727., 17273., 11424., 11796.,
      12168., 12540., 6223.,  6413.,  6603.,  6793.,  149.,   347.,   545.,
      743.,   1096.,  1500.,  1904.,  2308.,  2873.,  3491.,  4109.,  4727.,
      2987.,  3629.,  4271.,  4913.,  2928.,  3364.,  3800.,  4236.,  1943.,
      2165.,  2387.,  2609.,  2698.,  3126.,  3554.,  3982.,  7216.,  8088.,
      8960.,  9832.,  13618., 14950., 16282., 17614., 14134., 15514., 16894.,
      18274., 11520., 12456., 13392., 14328., 6830.,  7306.,  7782.,  8258.,
      8031.,  8721.,  9411.,  10101., 19128., 20532., 21936., 23340., 33387.,
      35529., 37671., 39813., 34593., 36807., 39021., 41235., 26544., 28044.,
      29544., 31044., 15045., 15807., 16569., 17331., 9034.,  9526.,  10018.,
      10510., 20336., 21336., 22336., 23336., 33970., 35494., 37018., 38542.,
      35062., 36634., 38206., 39778., 25920., 26984., 28048., 29112., 14254.,
      14794., 15334., 15874., 6485.,  6747.,  7009.,  7271.,  14216., 14748.,
      15280., 15812., 23225., 24035., 24845., 25655., 23915., 24749., 25583.,
      26417., 17328., 17892., 18456., 19020., 9367.,  9653.,  9939.,  10225.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4264.,   5320.,   6376.,   7432.,   10964.,  12740.,  14516.,  16292.,
      15044.,  17204.,  19364.,  21524.,  19124.,  21668.,  24212.,  26756.,
      23204.,  26132.,  29060.,  31988.,  21416.,  23496.,  25576.,  27656.,
      21228.,  23964.,  26700.,  29436.,  43878.,  48270.,  52662.,  57054.,
      53454.,  58422.,  63390.,  68358.,  63030.,  68574.,  74118.,  79662.,
      72606.,  78726.,  84846.,  90966.,  60780.,  65052.,  69324.,  73596.,
      54924.,  59964.,  65004.,  70044.,  101334., 109182., 117030., 124878.,
      110910., 119334., 127758., 136182., 120486., 129486., 138486., 147486.,
      130062., 139638., 149214., 158790., 103692., 110268., 116844., 123420.,
      88620.,  95964.,  103308., 110652., 158790., 170094., 181398., 192702.,
      168366., 180246., 192126., 204006., 177942., 190398., 202854., 215310.,
      187518., 200550., 213582., 226614., 146604., 155484., 164364., 173244.,
      111976., 117640., 123304., 128968., 188660., 197348., 206036., 214724.,
      197348., 206420., 215492., 224564., 206036., 215492., 224948., 234404.,
      214724., 224564., 234404., 244244., 159848., 166536., 173224., 179912.,
      70504.,  79240.,  87976.,  96712.,  133364., 146660., 159956., 173252.,
      137444., 151124., 164804., 178484., 141524., 155588., 169652., 183716.,
      145604., 160052., 174500., 188948., 118376., 128136., 137896., 147656.,
      189708., 203964., 218220., 232476., 331158., 352830., 374502., 396174.,
      340734., 362982., 385230., 407478., 350310., 373134., 395958., 418782.,
      359886., 383286., 406686., 430086., 275340., 291132., 306924., 322716.,
      223404., 239964., 256524., 273084., 388614., 413742., 438870., 463998.,
      398190., 423894., 449598., 475302., 407766., 434046., 460326., 486606.,
      417342., 444198., 471054., 497910., 318252., 336348., 354444., 372540.,
      257100., 275964., 294828., 313692., 446070., 474654., 503238., 531822.,
      455646., 484806., 513966., 543126., 465222., 494958., 524694., 554430.,
      474798., 505110., 535422., 565734., 361164., 381564., 401964., 422364.,
      270376., 283720., 297064., 310408., 449300., 469508., 489716., 509924.,
      457988., 478580., 499172., 519764., 466676., 487652., 508628., 529604.,
      475364., 496724., 518084., 539444., 348968., 363336., 377704., 392072.,
      136744., 153160., 169576., 185992., 255764., 280580., 305396., 330212.,
      259844., 285044., 310244., 335444., 263924., 289508., 315092., 340676.,
      268004., 293972., 319940., 345908., 215336., 232776., 250216., 267656.,
      358188., 383964., 409740., 435516., 618438., 657390., 696342., 735294.,
      628014., 667542., 707070., 746598., 637590., 677694., 717798., 757902.,
      647166., 687846., 728526., 769206., 489900., 517212., 544524., 571836.,
      391884., 419964., 448044., 476124., 675894., 718302., 760710., 803118.,
      685470., 728454., 771438., 814422., 695046., 738606., 782166., 825726.,
      704622., 748758., 792894., 837030., 532812., 562428., 592044., 621660.,
      425580., 455964., 486348., 516732., 733350., 779214., 825078., 870942.,
      742926., 789366., 835806., 882246., 752502., 799518., 846534., 893550.,
      762078., 809670., 857262., 904854., 575724., 607644., 639564., 671484.,
      428776., 449800., 470824., 491848., 709940., 741668., 773396., 805124.,
      718628., 750740., 782852., 814964., 727316., 759812., 792308., 824804.,
      736004., 768884., 801764., 834644., 538088., 560136., 582184., 604232.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,     70.,     110.,    150.,    260.,    404.,    548.,    692.,
      946.,    1258.,   1570.,   1882.,   1834.,   2338.,   2842.,   3346.,
      2532.,   2932.,   3332.,   3732.,   2006.,   2238.,   2470.,   2702.,
      700.,    1036.,   1372.,   1708.,   3592.,   4392.,   5192.,   5992.,
      9188.,   10580.,  11972.,  13364.,  13268.,  15044.,  16820.,  18596.,
      13256.,  14568.,  15880.,  17192.,  9004.,   9724.,   10444.,  11164.,
      5082.,   5970.,   6858.,   7746.,   16140.,  18108.,  20076.,  22044.,
      33942.,  37182.,  40422.,  43662.,  43518.,  47334.,  51150.,  54966.,
      38316.,  41052.,  43788.,  46524.,  24066.,  25530.,  26994.,  28458.,
      14268.,  15116.,  15964.,  16812.,  34312.,  36136.,  37960.,  39784.,
      60644.,  63572.,  66500.,  69428.,  69332.,  72644.,  75956.,  79268.,
      54216.,  56552.,  58888.,  61224.,  31276.,  32508.,  33740.,  34972.,
      13598.,  14150.,  14702.,  15254.,  30980.,  32148.,  33316.,  34484.,
      52402.,  54250.,  56098.,  57946.,  57898.,  59938.,  61978.,  64018.,
      43492.,  44916.,  46340.,  47764.,  24278.,  25022.,  25766.,  26510.,
      510.,    1318.,   2126.,   2934.,   4292.,   5972.,   7652.,   9332.,
      11602.,  14218.,  16834.,  19450.,  12490.,  15298.,  18106.,  20914.,
      12708.,  14644.,  16580.,  18516.,  8630.,   9630.,   10630.,  11630.,
      10876.,  12748.,  14620.,  16492.,  30088.,  33960.,  37832.,  41704.,
      58148.,  64148.,  70148.,  76148.,  62228.,  68612.,  74996.,  81380.,
      52040.,  56424.,  60808.,  65192.,  31468.,  33724.,  35980.,  38236.,
      34170.,  37362.,  40554.,  43746.,  83532.,  90108.,  96684.,  103260.,
      148854., 159006., 169158., 179310., 158430., 169158., 179886., 190614.,
      124140., 131484., 138828., 146172., 71586.,  75354.,  79122.,  82890.,
      42876.,  45260.,  47644.,  50028.,  97672.,  102568., 107464., 112360.,
      164900., 172436., 179972., 187508., 173588., 181508., 189428., 197348.,
      129864., 135272., 140680., 146088., 72172.,  74940.,  77708.,  80476.,
      32510.,  33830.,  35150.,  36470.,  71876.,  74580.,  77284.,  79988.,
      118354., 122506., 126658., 130810., 123850., 128194., 132538., 136882.,
      90532.,  93492.,  96452.,  99412.,  49334.,  50846.,  52358.,  53870.,
      990.,    2566.,   4142.,   5718.,   8324.,   11540.,  14756.,  17972.,
      22258.,  27178.,  32098.,  37018.,  23146.,  28258.,  33370.,  38482.,
      22884.,  26356.,  29828.,  33300.,  15254.,  17022.,  18790.,  20558.,
      21052.,  24460.,  27868.,  31276.,  56584.,  63528.,  70472.,  77416.,
      107108., 117716., 128324., 138932., 111188., 122180., 133172., 144164.,
      90824.,  98280.,  105736., 113192., 53932.,  57724.,  61516.,  65308.,
      63258.,  68754.,  74250.,  79746.,  150924., 162108., 173292., 184476.,
      263766., 280830., 297894., 314958., 273342., 290982., 308622., 326262.,
      209964., 221916., 233868., 245820., 119106., 125178., 131250., 137322.,
      71484.,  75404.,  79324.,  83244.,  161032., 169000., 176968., 184936.,
      269156., 281300., 293444., 305588., 277844., 290372., 302900., 315428.,
      205512., 213992., 222472., 230952., 113068., 117372., 121676., 125980.,
      51422.,  53510.,  55598.,  57686.,  112772., 117012., 121252., 125492.,
      184306., 190762., 197218., 203674., 189802., 196450., 203098., 209746.,
      137572., 142068., 146564., 151060., 74390.,  76670.,  78950.,  81230.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29.,   62.,   83.,   75.,   99.,   192.,  237.,  198.,  207.,
      372.,  417.,  330.,  315.,  552.,  597.,  462.,  423.,  732.,
      777.,  594.,  455.,  758.,  797.,  589.,  317.,  566.,  587.,
      459.,  747.,  1272., 1317., 990.,  855.,  1452., 1497., 1122.,
      963.,  1632., 1677., 1254., 1071., 1812., 1857., 1386., 1031.,
      1694., 1733., 1261., 605.,  1070., 1091., 843.,  1395., 2352.,
      2397., 1782., 1503., 2532., 2577., 1914., 1611., 2712., 2757.,
      2046., 1719., 2892., 2937., 2178., 1607., 2630., 2669., 1933.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   4.,   7.,   6.,   7.,   23.,  33.,  24.,  24.,  69.,  90.,  60.,
      48.,  123., 156., 96.,  63.,  149., 175., 102., 49.,  112., 127., 72.,
      9.,   28.,  47.,  30.,  47.,  119., 161., 96.,  120., 285., 354., 204.,
      144., 339., 420., 240., 151., 341., 399., 222., 105., 232., 263., 144.,
      17.,  52.,  87.,  54.,  87.,  215., 289., 168., 216., 501., 618., 348.,
      240., 555., 684., 384., 239., 533., 623., 342., 161., 352., 399., 216.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      184.,   412.,   568.,   528.,   678.,   1347.,  1689.,  1434.,  1494.,
      2715.,  3057.,  2442.,  2310.,  4083.,  4425.,  3450.,  3126.,  5451.,
      5793.,  4458.,  3440.,  5752.,  6052.,  4488.,  2296.,  4156.,  4312.,
      3408.,  5574.,  9555.,  9897.,  7482.,  6390.,  10923., 11265., 8490.,
      7206.,  12291., 12633., 9498.,  8022.,  13659., 14001., 10506., 7856.,
      12952., 13252., 9672.,  4408.,  7900.,  8056.,  6288.,  10470., 17763.,
      18105., 13530., 11286., 19131., 19473., 14538., 12102., 20499., 20841.,
      15546., 12918., 21867., 22209., 16554., 12272., 20152., 20452., 14856.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    22.,   42.,   39.,   40.,   144.,  216.,  164.,  153.,
      462.,  618.,  423.,  333.,  870.,  1122., 699.,  460.,  1096.,
      1296., 760.,  365.,  838.,  954.,  543.,  53.,   182.,  330.,
      215.,  328.,  848.,  1176., 708.,  873.,  2094., 2634., 1527.,
      1053., 2502., 3138., 1803., 1132., 2568., 3024., 1688., 797.,
      1766., 2010., 1103., 101.,  342.,  618.,  391.,  616.,  1552.,
      2136., 1252., 1593., 3726., 4650., 2631., 1773., 4134., 5154.,
      2907., 1804., 4040., 4752., 2616., 1229., 2694., 3066., 1663.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1288.,   2972.,   4172.,   3944.,   4980.,  10038.,  12702.,  10884.,
      11316.,  20694.,  23358.,  18756.,  17652., 31350.,  34014.,  26628.,
      23988.,  42006.,  44670.,  34500.,  26728., 44780.,  47132.,  35016.,
      17416.,  31772.,  32972.,  26216.,  42996., 73974.,  76638.,  58116.,
      49332.,  84630.,  87294.,  65988.,  55668., 95286.,  97950.,  73860.,
      62004.,  105942., 108606., 81732.,  61288., 101228., 103580., 75720.,
      33544.,  60572.,  61772.,  48488.,  81012., 137910., 140574., 105348.,
      87348.,  148566., 151230., 113220., 93684., 159222., 161886., 121092.,
      100020., 169878., 172542., 128964., 95848., 157676., 160028., 116424.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    140.,   284.,   278.,   260.,   1000.,  1544.,  1204.,  1074.,
      3348.,  4548.,  3162.,  2466.,  6516.,  8484.,  5322.,  3508.,  8392.,
      9960.,  5860.,  2814.,  6476.,  7388.,  4214.,  350.,   1292.,  2460.,
      1622.,  2436.,  6376.,  8968.,  5428.,  6642.,  16020., 20292., 11802.,
      8034.,  19188., 24228., 13962., 8756.,  19912., 23528., 13156., 6206.,
      13772., 15708., 8630.,  670.,   2444.,  4636.,  2966.,  4612.,  11752.,
      16392., 9652.,  12210., 28692., 36036., 20442., 13602., 31860., 39972.,
      22602., 14004., 31432., 37096., 20452., 9598.,  21068., 24028., 13046.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      44.,   58.,   100.,  124.,  136.,  166.,  128.,  150.,  165.,  198.,
      330.,  384.,  411.,  474.,  351.,  396.,  357.,  414.,  654.,  744.,
      735.,  834.,  591.,  660.,  549.,  630.,  978.,  1104., 1059., 1194.,
      831.,  924.,  741.,  846.,  1302., 1464., 1383., 1554., 1071., 1188.,
      832.,  910.,  1396., 1516., 1468., 1594., 1092., 1178., 524.,  634.,
      964.,  1132., 1000., 1174., 800.,  918.,  1317., 1494., 2274., 2544.,
      2355., 2634., 1791., 1980., 1509., 1710., 2598., 2904., 2679., 2994.,
      2031., 2244., 1701., 1926., 2922., 3264., 3003., 3354., 2271., 2508.,
      1893., 2142., 3246., 3624., 3327., 3714., 2511., 2772., 1888., 2062.,
      3124., 3388., 3196., 3466., 2340., 2522., 1004., 1210., 1828., 2140.,
      1864., 2182., 1472., 1686., 2469., 2790., 4218., 4704., 4299., 4794.,
      3231., 3564., 2661., 3006., 4542., 5064., 4623., 5154., 3471., 3828.,
      2853., 3222., 4866., 5424., 4947., 5514., 3711., 4092., 3045., 3438.,
      5190., 5784., 5271., 5874., 3951., 4356., 2944., 3214., 4852., 5260.,
      4924., 5338., 3588., 3866.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    2.,    5.,    8.,    11.,   14.,   10.,   12.,   10.,  14.,  36.,
      46.,   56.,   66.,   42.,   48.,   39.,   48.,   117.,  138., 159., 180.,
      108.,  120.,  81.,   96.,   213.,  246.,  279.,  312.,  174., 192., 114.,
      126.,  272.,  298.,  324.,  350.,  190.,  204.,  91.,   98.,  209., 224.,
      239.,  254.,  136.,  144.,  9.,    18.,   37.,   56.,   75.,  94.,  50.,
      60.,   74.,   94.,   196.,  238.,  280.,  322.,  170.,  192., 207., 240.,
      501.,  570.,  639.,  708.,  372.,  408.,  249.,  288.,  597., 678., 759.,
      840.,  438.,  480.,  274.,  302.,  624.,  682.,  740.,  798., 414., 444.,
      195.,  210.,  433.,  464.,  495.,  526.,  272.,  288.,  17.,  34.,  69.,
      104.,  139.,  174.,  90.,   108.,  138.,  174.,  356.,  430., 504., 578.,
      298.,  336.,  375.,  432.,  885.,  1002., 1119., 1236., 636., 696., 417.,
      480.,  981.,  1110., 1239., 1368., 702.,  768.,  434.,  478., 976., 1066.,
      1156., 1246., 638.,  684.,  299.,  322.,  657.,  704.,  751., 798., 408.,
      432.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      288.,   392.,   686.,   866.,   962.,   1190.,  928.,   1096.,  1164.,
      1416.,  2379.,  2793.,  3009.,  3495.,  2604.,  2952.,  2652.,  3096.,
      4899.,  5601.,  5529.,  6303.,  4476.,  5016.,  4140.,  4776.,  7419.,
      8409.,  8049.,  9111.,  6348.,  7080.,  5628.,  6456.,  9939.,  11217.,
      10569., 11919., 8220.,  9144.,  6416.,  7032.,  10790., 11738., 11354.,
      12350., 8464.,  9144.,  3936.,  4808.,  7310.,  8642.,  7586.,  8966.,
      6112.,  7048.,  10092., 11496., 17499., 19641., 18129., 20343., 13836.,
      15336., 11580., 13176., 20019., 22449., 20649., 23151., 15708., 17400.,
      13068., 14856., 22539., 25257., 23169., 25959., 17580., 19464., 14556.,
      16536., 25059., 28065., 25689., 28767., 19452., 21528., 14672., 16056.,
      24326., 26426., 24890., 27038., 18256., 19704., 7584.,  9224.,  13934.,
      16418., 14210., 16742., 11296., 13000., 19020., 21576., 32619., 36489.,
      33249., 37191., 25068., 27720., 20508., 23256., 35139., 39297., 35769.,
      39999., 26940., 29784., 21996., 24936., 37659., 42105., 38289., 42807.,
      28812., 31848., 23484., 26616., 40179., 44913., 40809., 45615., 30684.,
      33912., 22928., 25080., 37862., 41114., 38426., 41726., 28048., 30264.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    11.,   28.,   48.,   68.,   88.,    67.,   81.,   58.,   86.,
      232.,  304.,  376.,  448.,  294.,  338.,   255.,  321.,  804.,  960.,
      1116., 1272., 777.,  867.,  579.,  693.,   1548., 1800., 2052., 2304.,
      1293., 1431., 850.,  942.,  2040., 2240.,  2440., 2640., 1438., 1546.,
      689.,  743.,  1588., 1704., 1820., 1936.,  1039., 1101., 53.,   123.,
      252.,  400.,  548.,  696.,  371.,  449.,   538.,  694.,  1448., 1776.,
      2104., 2432., 1286., 1458., 1551., 1809.,  3780., 4320., 4860., 5400.,
      2841., 3123., 1875., 2181., 4524., 5160.,  5796., 6432., 3357., 3687.,
      2098., 2318., 4792., 5248., 5704., 6160.,  3198., 3434., 1505., 1623.,
      3348., 3592., 3836., 4080., 2111., 2237.,  101.,  235.,  476.,  752.,
      1028., 1304., 675.,  817.,  1018., 1302.,  2664., 3248., 3832., 4416.,
      2278., 2578., 2847., 3297., 6756., 7680.,  8604., 9528., 4905., 5379.,
      3171., 3669., 7500., 8520., 9540., 10560., 5421., 5943., 3346., 3694.,
      7544., 8256., 8968., 9680., 4958., 5322.,  2321., 2503., 5108., 5480.,
      5852., 6224., 3183., 3373.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2056.,   2856.,   5044.,   6436.,   7204.,   8980.,   7048.,   8360.,
      8700.,   10668.,  18006.,  21246.,  22974.,  26790.,  20028.,  22764.,
      20412.,  23916.,  37878.,  43422.,  42846.,  48966.,  34812.,  39084.,
      32124.,  37164.,  57750.,  65598.,  62718.,  71142.,  49596.,  55404.,
      43836.,  50412.,  77622.,  87774.,  82590.,  93318.,  64380.,  71724.,
      50376.,  55272.,  84820.,  92356.,  89284.,  97204.,  66632.,  72040.,
      30472.,  37416.,  56884.,  67492.,  59044.,  70036.,  47752.,  55208.,
      78972.,  90156.,  137238., 154302., 142206., 159846., 108732., 120684.,
      90684.,  103404., 157110., 176478., 162078., 182022., 123516., 137004.,
      102396., 116652., 176982., 198654., 181950., 204198., 138300., 153324.,
      114108., 129900., 196854., 220830., 201822., 226374., 153084., 169644.,
      115656., 126696., 191956., 208708., 196420., 213556., 144200., 155752.,
      58888.,  71976.,  108724., 128548., 110884., 131092., 88456.,  102056.,
      149244., 169644., 256470., 287358., 261438., 292902., 197436., 218604.,
      160956., 182892., 276342., 309534., 281310., 315078., 212220., 234924.,
      172668., 196140., 296214., 331710., 301182., 337254., 227004., 251244.,
      184380., 209388., 316086., 353886., 321054., 359430., 241788., 267564.,
      180936., 198120., 299092., 325060., 303556., 329908., 221768., 239464.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    70.,    180.,   324.,   468.,   612.,   486.,   590.,   380.,
      588.,   1640.,  2184.,  2728.,  3272.,  2188.,  2524.,  1818.,  2322.,
      5916.,  7116.,  8316.,  9516.,  5874.,  6570.,  4362.,  5250.,  11772.,
      13740., 15708., 17676., 9954.,  11034., 6556.,  7276.,  15784., 17352.,
      18920., 20488., 11180., 12028., 5358.,  5782.,  12372., 13284., 14196.,
      15108., 8118.,  8606.,  350.,   902.,   1844.,  3012.,  4180.,  5348.,
      2854.,  3470.,  4092.,  5324.,  11112., 13704., 16296., 18888., 9996.,
      11356., 11994., 14034., 29340., 33612., 37884., 42156., 22194., 24426.,
      14538., 16962., 35196., 40236., 45276., 50316., 26274., 28890., 16412.,
      18156., 37544., 41160., 44776., 48392., 25132., 27004., 11822., 12758.,
      26324., 28260., 30196., 32132., 16630., 17630., 670.,   1734.,  3508.,
      5700.,  7892.,  10084., 5222.,  6350.,  7804.,  10060., 20584., 25224.,
      29864., 34504., 17804., 20188., 22170., 25746., 52764., 60108., 67452.,
      74796., 38514., 42282., 24714., 28674., 58620., 66732., 74844., 82956.,
      42594., 46746., 26268., 29036., 59304., 64968., 70632., 76296., 39084.,
      41980., 18286., 19734., 40276., 43236., 46196., 49156., 25142., 26654.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      74.,    88.,    102.,   116.,   176.,   200.,   224.,   248.,   242.,
      272.,   302.,   332.,   234.,   256.,   278.,   300.,   297.,   330.,
      363.,   396.,   606.,   660.,   714.,   768.,   759.,   822.,   885.,
      948.,   657.,   702.,   747.,   792.,   657.,   714.,   771.,   828.,
      1218.,  1308.,  1398.,  1488.,  1371.,  1470.,  1569.,  1668.,  1113.,
      1182.,  1251.,  1320.,  1017.,  1098.,  1179.,  1260.,  1830.,  1956.,
      2082.,  2208.,  1983.,  2118.,  2253.,  2388.,  1569.,  1662.,  1755.,
      1848.,  1377.,  1482.,  1587.,  1692.,  2442.,  2604.,  2766.,  2928.,
      2595.,  2766.,  2937.,  3108.,  2025.,  2142.,  2259.,  2376.,  1586.,
      1664.,  1742.,  1820.,  2672.,  2792.,  2912.,  3032.,  2810.,  2936.,
      3062.,  3188.,  2098.,  2184.,  2270.,  2356.,  938.,   1048.,  1158.,
      1268.,  1760.,  1928.,  2096.,  2264.,  1826.,  2000.,  2174.,  2348.,
      1482.,  1600.,  1718.,  1836.,  2457.,  2634.,  2811.,  2988.,  4278.,
      4548.,  4818.,  5088.,  4431.,  4710.,  4989.,  5268.,  3393.,  3582.,
      3771.,  3960.,  2817.,  3018.,  3219.,  3420.,  4890.,  5196.,  5502.,
      5808.,  5043.,  5358.,  5673.,  5988.,  3849.,  4062.,  4275.,  4488.,
      3177.,  3402.,  3627.,  3852.,  5502.,  5844.,  6186.,  6528.,  5655.,
      6006.,  6357.,  6708.,  4305.,  4542.,  4779.,  5016.,  3537.,  3786.,
      4035.,  4284.,  6114.,  6492.,  6870.,  7248.,  6267.,  6654.,  7041.,
      7428.,  4761.,  5022.,  5283.,  5544.,  3602.,  3776.,  3950.,  4124.,
      5984.,  6248.,  6512.,  6776.,  6122.,  6392.,  6662.,  6932.,  4498.,
      4680.,  4862.,  5044.,  1802.,  2008.,  2214.,  2420.,  3344.,  3656.,
      3968.,  4280.,  3410.,  3728.,  4046.,  4364.,  2730.,  2944.,  3158.,
      3372.,  4617.,  4938.,  5259.,  5580.,  7950.,  8436.,  8922.,  9408.,
      8103.,  8598.,  9093.,  9588.,  6129.,  6462.,  6795.,  7128.,  4977.,
      5322.,  5667.,  6012.,  8562.,  9084.,  9606.,  10128., 8715.,  9246.,
      9777.,  10308., 6585.,  6942.,  7299.,  7656.,  5337.,  5706.,  6075.,
      6444.,  9174.,  9732.,  10290., 10848., 9327.,  9894.,  10461., 11028.,
      7041.,  7422.,  7803.,  8184.,  5697.,  6090.,  6483.,  6876.,  9786.,
      10380., 10974., 11568., 9939.,  10542., 11145., 11748., 7497.,  7902.,
      8307.,  8712.,  5618.,  5888.,  6158.,  6428.,  9296.,  9704.,  10112.,
      10520., 9434.,  9848.,  10262., 10676., 6898.,  7176.,  7454.,  7732.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    2.,    3.,    4.,    7.,    10.,   13.,   16.,   19.,   22.,
      25.,   28.,   18.,   20.,   22.,   24.,   16.,   20.,   24.,   28.,
      62.,   72.,   82.,   92.,   102.,  112.,  122.,  132.,  78.,   84.,
      90.,   96.,   69.,   78.,   87.,   96.,   213.,  234.,  255.,  276.,
      297.,  318.,  339.,  360.,  204.,  216.,  228.,  240.,  147.,  162.,
      177.,  192.,  393.,  426.,  459.,  492.,  525.,  558.,  591.,  624.,
      330.,  348.,  366.,  384.,  216.,  228.,  240.,  252.,  518.,  544.,
      570.,  596.,  622.,  648.,  674.,  700.,  366.,  380.,  394.,  408.,
      175.,  182.,  189.,  196.,  403.,  418.,  433.,  448.,  463.,  478.,
      493.,  508.,  264.,  272.,  280.,  288.,  9.,    18.,   27.,   36.,
      55.,   74.,   93.,   112.,  131.,  150.,  169.,  188.,  90.,   100.,
      110.,  120.,  128.,  148.,  168.,  188.,  350.,  392.,  434.,  476.,
      518.,  560.,  602.,  644.,  318.,  340.,  362.,  384.,  381.,  414.,
      447.,  480.,  933.,  1002., 1071., 1140., 1209., 1278., 1347., 1416.,
      708.,  744.,  780.,  816.,  459.,  498.,  537.,  576.,  1113., 1194.,
      1275., 1356., 1437., 1518., 1599., 1680., 834.,  876.,  918.,  960.,
      520.,  548.,  576.,  604.,  1190., 1248., 1306., 1364., 1422., 1480.,
      1538., 1596., 798.,  828.,  858.,  888.,  375.,  390.,  405.,  420.,
      835.,  866.,  897.,  928.,  959.,  990.,  1021., 1052., 528.,  544.,
      560.,  576.,  17.,   34.,   51.,   68.,   103.,  138.,  173.,  208.,
      243.,  278.,  313.,  348.,  162.,  180.,  198.,  216.,  240.,  276.,
      312.,  348.,  638.,  712.,  786.,  860.,  934.,  1008., 1082., 1156.,
      558.,  596.,  634.,  672.,  693.,  750.,  807.,  864.,  1653., 1770.,
      1887., 2004., 2121., 2238., 2355., 2472., 1212., 1272., 1332., 1392.,
      771.,  834.,  897.,  960.,  1833., 1962., 2091., 2220., 2349., 2478.,
      2607., 2736., 1338., 1404., 1470., 1536., 824.,  868.,  912.,  956.,
      1862., 1952., 2042., 2132., 2222., 2312., 2402., 2492., 1230., 1276.,
      1322., 1368., 575.,  598.,  621.,  644.,  1267., 1314., 1361., 1408.,
      1455., 1502., 1549., 1596., 792.,  816.,  840.,  864.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      496.,   600.,   704.,   808.,   1234.,  1414.,  1594.,  1774.,  1750.,
      1978.,  2206.,  2434.,  1728.,  1896.,  2064.,  2232.,  2136.,  2388.,
      2640.,  2892.,  4443.,  4857.,  5271.,  5685.,  5649.,  6135.,  6621.,
      7107.,  4944.,  5292.,  5640.,  5988.,  4968.,  5412.,  5856.,  6300.,
      9267.,  9969.,  10671., 11373., 10473., 11247., 12021., 12795., 8544.,
      9084.,  9624.,  10164., 7800.,  8436.,  9072.,  9708.,  14091., 15081.,
      16071., 17061., 15297., 16359., 17421., 18483., 12144., 12876., 13608.,
      14340., 10632., 11460., 12288., 13116., 18915., 20193., 21471., 22749.,
      20121., 21471., 22821., 24171., 15744., 16668., 17592., 18516., 12368.,
      12984., 13600., 14216., 20866., 21814., 22762., 23710., 21958., 22954.,
      23950., 24946., 16416., 17096., 17776., 18456., 7216.,  8088.,  8960.,
      9832.,  13618., 14950., 16282., 17614., 14134., 15514., 16894., 18274.,
      11520., 12456., 13392., 14328., 19128., 20532., 21936., 23340., 33387.,
      35529., 37671., 39813., 34593., 36807., 39021., 41235., 26544., 28044.,
      29544., 31044., 21960., 23556., 25152., 26748., 38211., 40641., 43071.,
      45501., 39417., 41919., 44421., 46923., 30144., 31836., 33528., 35220.,
      24792., 26580., 28368., 30156., 43035., 45753., 48471., 51189., 44241.,
      47031., 49821., 52611., 33744., 35628., 37512., 39396., 27624., 29604.,
      31584., 33564., 47859., 50865., 53871., 56877., 49065., 52143., 55221.,
      58299., 37344., 39420., 41496., 43572., 28304., 29688., 31072., 32456.,
      47074., 49174., 51274., 53374., 48166., 50314., 52462., 54610., 35424.,
      36872., 38320., 39768., 13936., 15576., 17216., 18856., 26002., 28486.,
      30970., 33454., 26518., 29050., 31582., 34114., 21312., 23016., 24720.,
      26424., 36120., 38676., 41232., 43788., 62331., 66201., 70071., 73941.,
      63537., 67479., 71421., 75363., 48144., 50796., 53448., 56100., 38952.,
      41700., 44448., 47196., 67155., 71313., 75471., 79629., 68361., 72591.,
      76821., 81051., 51744., 54588., 57432., 60276., 41784., 44724., 47664.,
      50604., 71979., 76425., 80871., 85317., 73185., 77703., 82221., 86739.,
      55344., 58380., 61416., 64452., 44616., 47748., 50880., 54012., 76803.,
      81537., 86271., 91005., 78009., 82815., 87621., 92427., 58944., 62172.,
      65400., 68628., 44240., 46392., 48544., 50696., 73282., 76534., 79786.,
      83038., 74374., 77674., 80974., 84274., 54432., 56648., 58864., 61080.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,     11.,    17.,    23.,    40.,    60.,    80.,    100.,   120.,
      140.,   160.,   180.,   123.,   137.,   151.,   165.,   94.,    122.,
      150.,   178.,   408.,   480.,   552.,   624.,   696.,   768.,   840.,
      912.,   554.,   598.,   642.,   686.,   459.,   525.,   591.,   657.,
      1488.,  1644.,  1800.,  1956.,  2112.,  2268.,  2424.,  2580.,  1485.,
      1575.,  1665.,  1755.,  1071.,  1185.,  1299.,  1413.,  2904.,  3156.,
      3408.,  3660.,  3912.,  4164.,  4416.,  4668.,  2481.,  2619.,  2757.,
      2895.,  1630.,  1722.,  1814.,  1906.,  3928.,  4128.,  4328.,  4528.,
      4728.,  4928.,  5128.,  5328.,  2794.,  2902.,  3010.,  3118.,  1337.,
      1391.,  1445.,  1499.,  3088.,  3204.,  3320.,  3436.,  3552.,  3668.,
      3784.,  3900.,  2031.,  2093.,  2155.,  2217.,  53.,    123.,   193.,
      263.,   392.,   540.,   688.,   836.,   984.,   1132.,  1280.,  1428.,
      683.,   761.,   839.,   917.,   958.,   1114.,  1270.,  1426.,  2648.,
      2976.,  3304.,  3632.,  3960.,  4288.,  4616.,  4944.,  2442.,  2614.,
      2786.,  2958.,  2907.,  3165.,  3423.,  3681.,  7152.,  7692.,  8232.,
      8772.,  9312.,  9852.,  10392., 10932., 5469.,  5751.,  6033.,  6315.,
      3519.,  3825.,  4131.,  4437.,  8568.,  9204.,  9840.,  10476., 11112.,
      11748., 12384., 13020., 6465.,  6795.,  7125.,  7455.,  4030.,  4250.,
      4470.,  4690.,  9240.,  9696.,  10152., 10608., 11064., 11520., 11976.,
      12432., 6218.,  6454.,  6690.,  6926.,  2921.,  3039.,  3157.,  3275.,
      6512.,  6756.,  7000.,  7244.,  7488.,  7732.,  7976.,  8220.,  4127.,
      4253.,  4379.,  4505.,  101.,   235.,   369.,   503.,   744.,   1020.,
      1296.,  1572.,  1848.,  2124.,  2400.,  2676.,  1243.,  1385.,  1527.,
      1669.,  1822.,  2106.,  2390.,  2674.,  4888.,  5472.,  6056.,  6640.,
      7224.,  7808.,  8392.,  8976.,  4330.,  4630.,  4930.,  5230.,  5355.,
      5805.,  6255.,  6705.,  12816., 13740., 14664., 15588., 16512., 17436.,
      18360., 19284., 9453.,  9927.,  10401., 10875., 5967.,  6465.,  6963.,
      7461.,  14232., 15252., 16272., 17292., 18312., 19332., 20352., 21372.,
      10449., 10971., 11493., 12015., 6430.,  6778.,  7126.,  7474.,  14552.,
      15264., 15976., 16688., 17400., 18112., 18824., 19536., 9642.,  10006.,
      10370., 10734., 4505.,  4687.,  4869.,  5051.,  9936.,  10308., 10680.,
      11052., 11424., 11796., 12168., 12540., 6223.,  6413.,  6603.,  6793.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3592.,   4392.,   5192.,   5992.,   9188.,   10580.,  11972.,  13364.,
      13268.,  15044.,  16820.,  18596.,  13256.,  14568.,  15880.,  17192.,
      16140.,  18108.,  20076.,  22044.,  33942.,  37182.,  40422.,  43662.,
      43518.,  47334.,  51150.,  54966.,  38316.,  41052.,  43788.,  46524.,
      38604.,  42108.,  45612.,  49116.,  72246.,  77790.,  83334.,  88878.,
      81822.,  87942.,  94062.,  100182., 66924.,  71196.,  75468.,  79740.,
      61068.,  66108.,  71148.,  76188.,  110550., 118398., 126246., 134094.,
      120126., 128550., 136974., 145398., 95532.,  101340., 107148., 112956.,
      83532.,  90108.,  96684.,  103260., 148854., 159006., 169158., 179310.,
      158430., 169158., 179886., 190614., 124140., 131484., 138828., 146172.,
      97672.,  102568., 107464., 112360., 164900., 172436., 179972., 187508.,
      173588., 181508., 189428., 197348., 129864., 135272., 140680., 146088.,
      56584.,  63528.,  70472.,  77416.,  107108., 117716., 128324., 138932.,
      111188., 122180., 133172., 144164., 90824.,  98280.,  105736., 113192.,
      150924., 162108., 173292., 184476., 263766., 280830., 297894., 314958.,
      273342., 290982., 308622., 326262., 209964., 221916., 233868., 245820.,
      173388., 186108., 198828., 211548., 302070., 321438., 340806., 360174.,
      311646., 331590., 351534., 371478., 238572., 252060., 265548., 279036.,
      195852., 210108., 224364., 238620., 340374., 362046., 383718., 405390.,
      349950., 372198., 394446., 416694., 267180., 282204., 297228., 312252.,
      218316., 234108., 249900., 265692., 378678., 402654., 426630., 450606.,
      388254., 412806., 437358., 461910., 295788., 312348., 328908., 345468.,
      224392., 235432., 246472., 257512., 373412., 390164., 406916., 423668.,
      382100., 399236., 416372., 433508., 281160., 292712., 304264., 315816.,
      109576., 122664., 135752., 148840., 205028., 224852., 244676., 264500.,
      209108., 229316., 249524., 269732., 168392., 181992., 195592., 209192.,
      285708., 306108., 326508., 346908., 493590., 524478., 555366., 586254.,
      503166., 534630., 566094., 597558., 381612., 402780., 423948., 445116.,
      308172., 330108., 352044., 373980., 531894., 565086., 598278., 631470.,
      541470., 575238., 609006., 642774., 410220., 432924., 455628., 478332.,
      330636., 354108., 377580., 401052., 570198., 605694., 641190., 676686.,
      579774., 615846., 651918., 687990., 438828., 463068., 487308., 511548.,
      353100., 378108., 403116., 428124., 608502., 646302., 684102., 721902.,
      618078., 656454., 694830., 733206., 467436., 493212., 518988., 544764.,
      351112., 368296., 385480., 402664., 581924., 607892., 633860., 659828.,
      590612., 616964., 643316., 669668., 432456., 450152., 467848., 485544.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,     70.,     110.,    150.,    260.,    404.,    548.,    692.,
      836.,    980.,    1124.,   1268.,   902.,    1006.,   1110.,   1214.,
      620.,    828.,    1036.,   1244.,   2920.,   3464.,   4008.,   4552.,
      5096.,   5640.,   6184.,   6728.,   4156.,   4492.,   4828.,   5164.,
      3306.,   3810.,   4314.,   4818.,   11052.,  12252.,  13452.,  14652.,
      15852.,  17052.,  18252.,  19452.,  11298.,  11994.,  12690.,  13386.,
      8154.,   9042.,   9930.,   10818.,  22284.,  24252.,  26220.,  28188.,
      30156.,  32124.,  34092.,  36060.,  19218.,  20298.,  21378.,  22458.,
      12652.,  13372.,  14092.,  14812.,  30568.,  32136.,  33704.,  35272.,
      36840.,  38408.,  39976.,  41544.,  21820.,  22668.,  23516.,  24364.,
      10446.,  10870.,  11294.,  11718.,  24164.,  25076.,  25988.,  26900.,
      27812.,  28724.,  29636.,  30548.,  15926.,  16414.,  16902.,  17390.,
      350.,    902.,    1454.,   2006.,   2948.,   4116.,   5284.,   6452.,
      7620.,   8788.,   9956.,   11124.,  5318.,   5934.,   6550.,   7166.,
      7404.,   8636.,   9868.,   11100.,  20584.,  23176.,  25768.,  28360.,
      30952.,  33544.,  36136.,  38728.,  19132.,  20492.,  21852.,  23212.,
      22698.,  24738.,  26778.,  28818.,  55980.,  60252.,  64524.,  68796.,
      73068.,  77340.,  81612.,  85884.,  42978.,  45210.,  47442.,  49674.,
      27546.,  29970.,  32394.,  34818.,  67212.,  72252.,  77292.,  82332.,
      87372.,  92412.,  97452.,  102492., 50898.,  53514.,  56130.,  58746.,
      31724.,  33468.,  35212.,  36956.,  72808.,  76424.,  80040.,  83656.,
      87272.,  90888.,  94504.,  98120.,  49084.,  50956.,  52828.,  54700.,
      23054.,  23990.,  24926.,  25862.,  51428.,  53364.,  55300.,  57236.,
      59172.,  61108.,  63044.,  64980.,  32630.,  33630.,  34630.,  35630.,
      670.,    1734.,   2798.,   3862.,   5636.,   7828.,   10020.,  12212.,
      14404.,  16596.,  18788.,  20980.,  9734.,   10862.,  11990.,  13118.,
      14188.,  16444.,  18700.,  20956.,  38248.,  42888.,  47528.,  52168.,
      56808.,  61448.,  66088.,  70728.,  34108.,  36492.,  38876.,  41260.,
      42090.,  45666.,  49242.,  52818.,  100908., 108252., 115596., 122940.,
      130284., 137628., 144972., 152316., 74658.,  78426.,  82194.,  85962.,
      46938.,  50898.,  54858.,  58818.,  112140., 120252., 128364., 136476.,
      144588., 152700., 160812., 168924., 82578.,  86730.,  90882.,  95034.,
      50796.,  53564.,  56332.,  59100.,  115048., 120712., 126376., 132040.,
      137704., 143368., 149032., 154696., 76348.,  79244.,  82140.,  85036.,
      35662.,  37110.,  38558.,  40006.,  78692.,  81652.,  84612.,  87572.,
      90532.,  93492.,  96452.,  99412.,  49334.,  50846.,  52358.,  53870.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      32.,   68.,   89.,   110.,  96.,   114.,  219.,  264.,  309.,  252.,
      249.,  444.,  489.,  534.,  417.,  384.,  669.,  714.,  759.,  582.,
      519.,  894.,  939.,  984.,  747.,  560.,  929.,  968.,  1007., 740.,
      392.,  698.,  719.,  740.,  576.,  924.,  1569., 1614., 1659., 1242.,
      1059., 1794., 1839., 1884., 1407., 1194., 2019., 2064., 2109., 1572.,
      1329., 2244., 2289., 2334., 1737., 1280., 2099., 2138., 2177., 1580.,
      752.,  1328., 1349., 1370., 1056., 1734., 2919., 2964., 3009., 2232.,
      1869., 3144., 3189., 3234., 2397., 2004., 3369., 3414., 3459., 2562.,
      2139., 3594., 3639., 3684., 2727., 2000., 3269., 3308., 3347., 2420.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   4.,   10.,   12.,  9.,   8.,   26.,  56.,   54.,   36.,
      30.,  84.,  165.,  144., 90.,  66.,  165., 300.,  243.,  144.,
      89.,  206., 353.,  270., 153., 70.,  157., 262.,  195.,  108.,
      13.,  40.,  82.,   72.,  45.,  68.,  170., 308.,  246.,  144.,
      174., 408., 705.,  540., 306., 210., 489., 840.,  639.,  360.,
      221., 494., 821.,  606., 333., 154., 337., 550.,  399.,  216.,
      25.,  76.,  154.,  132., 81.,  128., 314., 560.,  438.,  252.,
      318., 732., 1245., 936., 522., 354., 813., 1380., 1035., 576.,
      353., 782., 1289., 942., 513., 238., 517., 838.,  603.,  324.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      204.,   454.,   610.,   766.,   684.,   786.,   1545.,  1887.,  2229.,
      1842.,  1806.,  3255.,  3597.,  3939.,  3102.,  2826.,  4965.,  5307.,
      5649.,  4362.,  3846.,  6675.,  7017.,  7359.,  5622.,  4244.,  7066.,
      7366.,  7666.,  5652.,  2844.,  5134.,  5290.,  5446.,  4284.,  6906.,
      11805., 12147., 12489., 9402.,  7926.,  13515., 13857., 14199., 10662.,
      8946.,  15225., 15567., 15909., 11922., 9966.,  16935., 17277., 17619.,
      13182., 9764.,  16066., 16366., 16666., 12132., 5484.,  9814.,  9970.,
      10126., 7884.,  13026., 22065., 22407., 22749., 16962., 14046., 23775.,
      24117., 24459., 18222., 15066., 25485., 25827., 26169., 19482., 16086.,
      27195., 27537., 27879., 20742., 15284., 25066., 25366., 25666., 18612.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    22.,   59.,   78.,   61.,   46.,   164.,  370.,   372.,  254.,
      195.,  570.,  1149., 1026., 651.,  465.,  1182., 2175.,  1782., 1065.,
      658.,  1532., 2638., 2028., 1154., 527.,  1186., 1985.,  1482., 823.,
      77.,   262.,  563.,  510.,  325.,  478.,  1220., 2242.,  1812., 1070.,
      1275., 3018., 5253., 4050., 2307., 1545., 3630., 6279.,  4806., 2721.,
      1666., 3740., 6238., 4620., 2546., 1175., 2578., 4217.,  3066., 1663.,
      149.,  502.,  1067., 942.,  589.,  910.,  2276., 4114.,  3252., 1886.,
      2355., 5466., 9357., 7074., 3963., 2625., 6078., 10383., 7830., 4377.,
      2674., 5948., 9838., 7212., 3938., 1823., 3970., 6449.,  4650., 2503.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1432.,   3284.,   4484.,   5684.,   5144.,   5796.,   11550.,  14214.,
      16878.,  14052.,  13716.,  24870.,  27534.,  30198.,  23892.,  21636.,
      38190.,  40854.,  43518.,  33732.,  29556.,  51510.,  54174.,  56838.,
      43572.,  33016.,  55076.,  57428.,  59780.,  44152.,  21592.,  39284.,
      40484.,  41684.,  32984.,  53316.,  91470.,  94134.,  96798.,  73092.,
      61236.,  104790., 107454., 110118., 82932.,  69156.,  118110., 120774.,
      123438., 92772.,  77076.,  131430., 134094., 136758., 102612., 76216.,
      125636., 127988., 130340., 95032.,  41752.,  75284.,  76484.,  77684.,
      60824.,  100836., 171390., 174054., 176718., 132132., 108756., 184710.,
      187374., 190038., 141972., 116676., 198030., 200694., 203358., 151812.,
      124596., 211350., 214014., 216678., 161652., 119416., 196196., 198548.,
      200900., 145912.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    140.,   394.,   556.,   446.,   300.,   1144.,  2660.,  2744.,
      1900.,  1386.,  4164.,  8526.,  7716.,  4938.,  3474.,  8916.,  16518.,
      13620., 8178.,  5052.,  11800., 20372., 15704., 8956.,  4086.,  9212.,
      15442., 11548., 6422.,  510.,   1868.,  4138.,  3820.,  2462.,  3564.,
      9208.,  17060., 13880., 8236.,  9738.,  23172., 40494., 31332., 17898.,
      11826., 27924., 48486., 37236., 21138., 12924., 29080., 48596., 36056.,
      19900., 9174.,  20156., 33010., 24028., 13046., 990.,   3596.,  7882.,
      7084.,  4478.,  6828.,  17272., 31460., 25016., 14572., 18090., 42180.,
      72462., 54948., 30858., 20178., 46932., 80454., 60852., 34098., 20796.,
      46360., 76820., 56408., 30844., 14262., 31100., 50578., 36508., 19670.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      48.,   64.,   109.,  136.,  145.,  178.,  181.,  220.,  164.,  192.,
      189.,  228.,  375.,  438.,  456.,  528.,  537.,  618.,  447.,  504.,
      429.,  498.,  780.,  888.,  861.,  978.,  942.,  1068., 747.,  834.,
      669.,  768.,  1185., 1338., 1266., 1428., 1347., 1518., 1047., 1164.,
      909.,  1038., 1590., 1788., 1671., 1878., 1752., 1968., 1347., 1494.,
      1024., 1120., 1711., 1858., 1783., 1936., 1855., 2014., 1372., 1480.,
      648.,  784.,  1189., 1396., 1225., 1438., 1261., 1480., 1004., 1152.,
      1629., 1848., 2805., 3138., 2886., 3228., 2967., 3318., 2247., 2484.,
      1869., 2118., 3210., 3588., 3291., 3678., 3372., 3768., 2547., 2814.,
      2109., 2388., 3615., 4038., 3696., 4128., 3777., 4218., 2847., 3144.,
      2349., 2658., 4020., 4488., 4101., 4578., 4182., 4668., 3147., 3474.,
      2344., 2560., 3871., 4198., 3943., 4276., 4015., 4354., 2932., 3160.,
      1248., 1504., 2269., 2656., 2305., 2698., 2341., 2740., 1844., 2112.,
      3069., 3468., 5235., 5838., 5316., 5928., 5397., 6018., 4047., 4464.,
      3309., 3738., 5640., 6288., 5721., 6378., 5802., 6468., 4347., 4794.,
      3549., 4008., 6045., 6738., 6126., 6828., 6207., 6918., 4647., 5124.,
      3789., 4278., 6450., 7188., 6531., 7278., 6612., 7368., 4947., 5454.,
      3664., 4000., 6031., 6538., 6103., 6616., 6175., 6694., 4492., 4840.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   2.,   5.,    8.,    14.,   20.,   19.,   24.,   15.,   18.,
      11.,  16.,  40.,   52.,   91.,   112.,  92.,   108.,  63.,   72.,
      48.,  60.,  141.,  168.,  285.,  330.,  255.,  288.,  162.,  180.,
      111., 132., 285.,  330.,  528.,  600.,  435.,  486.,  261.,  288.,
      161., 178., 376.,  412.,  649.,  706.,  500.,  540.,  285.,  306.,
      130., 140., 293.,  314.,  491.,  524.,  367.,  390.,  204.,  216.,
      13.,  26.,  53.,   80.,   122.,  164.,  115.,  144.,  75.,   90.,
      107., 136., 280.,  340.,  523.,  616.,  428.,  492.,  255.,  288.,
      300., 348., 717.,  816.,  1257., 1410., 975.,  1080., 558.,  612.,
      363., 420., 861.,  978.,  1500., 1680., 1155., 1278., 657.,  720.,
      401., 442., 904.,  988.,  1513., 1642., 1124., 1212., 621.,  666.,
      286., 308., 629.,  674.,  1031., 1100., 751.,  798.,  408.,  432.,
      25.,  50.,  101.,  152.,  230.,  308.,  211.,  264.,  135.,  162.,
      203., 256., 520.,  628.,  955.,  1120., 764.,  876.,  447.,  504.,
      552., 636., 1293., 1464., 2229., 2490., 1695., 1872., 954.,  1044.,
      615., 708., 1437., 1626., 2472., 2760., 1875., 2070., 1053., 1152.,
      641., 706., 1432., 1564., 2377., 2578., 1748., 1884., 957.,  1026.,
      442., 476., 965.,  1034., 1571., 1676., 1135., 1206., 612.,  648.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      316.,   436.,   752.,   956.,   1028.,  1280.,  1304.,  1604.,  1204.,
      1420.,  1344.,  1644.,  2721.,  3207.,  3351.,  3909.,  3981.,  4611.,
      3348.,  3792.,  3204.,  3744.,  5871.,  6717.,  6501.,  7419.,  7131.,
      8121.,  5688.,  6372.,  5064.,  5844.,  9021.,  10227., 9651.,  10929.,
      10281., 11631., 8028.,  8952.,  6924.,  7944.,  12171., 13737., 12801.,
      14439., 13431., 15141., 10368., 11532., 7916.,  8676.,  13256., 14420.,
      13820., 15032., 14384., 15644., 10660., 11516., 4876.,  5956.,  9032.,
      10676., 9308.,  11000., 9584.,  11324., 7684.,  8860.,  12504., 14244.,
      21621., 24267., 22251., 24969., 22881., 25671., 17388., 19272., 14364.,
      16344., 24771., 27777., 25401., 28479., 26031., 29181., 19728., 21852.,
      16224., 18444., 27921., 31287., 28551., 31989., 29181., 32691., 22068.,
      24432., 18084., 20544., 31071., 34797., 31701., 35499., 32331., 36201.,
      24408., 27012., 18236., 19956., 30176., 32780., 30740., 33392., 31304.,
      34004., 22900., 24716., 9436.,  11476., 17312., 20396., 17588., 20720.,
      17864., 21044., 14164., 16300., 23664., 26844., 40521., 45327., 41151.,
      46029., 41781., 46731., 31428., 34752., 25524., 28944., 43671., 48837.,
      44301., 49539., 44931., 50241., 33768., 37332., 27384., 31044., 46821.,
      52347., 47451., 53049., 48081., 53751., 36108., 39912., 29244., 33144.,
      49971., 55857., 50601., 56559., 51231., 57261., 38448., 42492., 28556.,
      31236., 47096., 51140., 47660., 51752., 48224., 52364., 35140., 37916.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,     11.,    28.,    48.,    85.,    127.,   128.,   164.,  105.,
      127.,   64.,    100.,   260.,   348.,   620.,   776.,   652.,  772.,
      456.,   524.,   321.,   411.,   984.,   1188.,  2037.,  2379., 1860.,
      2112.,  1197.,  1335.,  807.,   969.,   2100.,  2448.,  3927., 4485.,
      3264.,  3660.,  1971.,  2181.,  1216.,  1348.,  2852.,  3132., 4940.,
      5384.,  3820.,  4132.,  2184.,  2348.,  995.,   1073.,  2248., 2412.,
      3775.,  4033.,  2828.,  3008.,  1575.,  1669.,  77.,    179.,  364.,
      576.,   877.,   1207.,  848.,   1076.,  561.,   679.,   784.,  1012.,
      2084.,  2556.,  3932.,  4664.,  3244.,  3748.,  1944.,  2204., 2265.,
      2643.,  5448.,  6228.,  9597.,  10803., 7476.,  8304.,  4293., 4719.,
      2751.,  3201.,  6564.,  7488.,  11487., 12909., 8880.,  9852., 5067.,
      5565.,  3088.,  3412.,  6980.,  7644.,  11708., 12728., 8716., 9412.,
      4824.,  5180.,  2219.,  2393.,  4888.,  5244.,  8023.,  8569., 5852.,
      6224.,  3183.,  3373.,  149.,   347.,   700.,   1104.,  1669., 2287.,
      1568.,  1988.,  1017.,  1231.,  1504.,  1924.,  3908.,  4764., 7244.,
      8552.,  5836.,  6724.,  3432.,  3884.,  4209.,  4875.,  9912., 11268.,
      17157., 19227., 13092., 14496., 7389.,  8103.,  4695.,  5433., 11028.,
      12528., 19047., 21333., 14496., 16044., 8163.,  8949.,  4960., 5476.,
      11108., 12156., 18476., 20072., 13612., 14692., 7464.,  8012., 3443.,
      3713.,  7528.,  8076.,  12271., 13105., 8876.,  9440.,  4791., 5077.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2264.,   3192.,   5548.,   7132.,   7708.,   9676.,   9868.,   12220.,
      9208.,   10904.,  10092.,  12444.,  20670.,  24486.,  25638.,  30030.,
      30606.,  35574.,  25884.,  29388.,  24732.,  29004.,  45510.,  52206.,
      50478.,  57750.,  55446.,  63294.,  44364.,  49788.,  39372.,  45564.,
      70350.,  79926.,  75318.,  85470.,  80286.,  91014.,  62844.,  70188.,
      54012.,  62124.,  95190.,  107646., 100158., 113190., 105126., 118734.,
      81324.,  90588.,  62232.,  68280.,  104332., 113596., 108796., 118444.,
      113260., 123292., 84024.,  90840.,  37784.,  46392.,  70348.,  83452.,
      72508.,  85996.,  74668.,  88540.,  60088.,  69464.,  97932.,  111804.,
      169710., 190806., 174678., 196350., 179646., 201894., 136764., 151788.,
      112572., 128364., 194550., 218526., 199518., 224070., 204486., 229614.,
      155244., 172188., 127212., 144924., 219390., 246246., 224358., 251790.,
      229326., 257334., 173724., 192588., 141852., 161484., 244230., 273966.,
      249198., 279510., 254166., 285054., 192204., 212988., 143832., 157560.,
      238252., 259036., 242716., 263884., 247180., 268732., 180984., 195480.,
      73304.,  89592.,  135148., 159772., 137308., 162316., 139468., 164860.,
      110968., 128024., 185772., 211164., 318750., 357126., 323718., 362670.,
      328686., 368214., 247644., 274188., 200412., 227724., 343590., 384846.,
      348558., 390390., 353526., 395934., 266124., 294588., 215052., 244284.,
      368430., 412566., 373398., 418110., 378366., 423654., 284604., 314988.,
      229692., 260844., 393270., 440286., 398238., 445830., 403206., 451374.,
      303084., 335388., 225432., 246840., 372172., 404476., 376636., 409324.,
      381100., 414172., 277944., 300120.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,     70.,     180.,    324.,    578.,    890.,    932.,    1204.,
      782.,    950.,    420.,    692.,    1848.,   2520.,   4540.,   5740.,
      4888.,   5816.,   3460.,   3988.,   2322.,   3018.,   7308.,   8892.,
      15342.,  18006.,  14172.,  16140.,  9186.,   10266.,  6138.,   7410.,
      16092.,  18828.,  30246.,  34638.,  25260.,  28380.,  15306.,  16962.,
      9444.,   10484.,  22200.,  24408.,  38524.,  42028.,  29848.,  32312.,
      17092.,  18388.,  7782.,   8398.,   17604.,  18900.,  29594.,  31634.,
      22196.,  23620.,  12374.,  13118.,  510.,    1318.,   2676.,   4356.,
      6626.,   9242.,   6500.,   8308.,   4334.,   5270.,   5988.,   7796.,
      16056.,  19800.,  30460.,  36268.,  25240.,  29240.,  15172.,  17236.,
      17586.,  20586.,  42444.,  48636.,  74958.,  84534.,  58524.,  65100.,
      33666.,  37050.,  21402.,  24978.,  51228.,  58572.,  89862.,  101166.,
      69612.,  77340.,  39786.,  43746.,  24228.,  26804.,  54840.,  60120.,
      92092.,  100204., 68632.,  74168.,  38020.,  40852.,  17478.,  18862.,
      38532.,  41364.,  63290.,  67634.,  46196.,  49156.,  25142.,  26654.,
      990.,    2566.,   5172.,   8388.,   12674.,  17594.,  12068.,  15412.,
      7886.,   9590.,   11556.,  14900.,  30264.,  37080.,  56380.,  66796.,
      45592.,  52664.,  26884.,  30484.,  32850.,  38154.,  77580.,  88380.,
      134574., 151062., 102876., 114060., 58146.,  63834.,  36666.,  42546.,
      86364.,  98316.,  149478., 167694., 113964., 126300., 64266.,  70530.,
      39012.,  43124.,  87480.,  95832.,  145660., 158380., 107416., 116024.,
      58948.,  63316.,  27174.,  29326.,  59460.,  63828.,  96986.,  103634.,
      70196.,  74692.,  37910.,  40190.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      80.,    96.,    112.,   128.,   191.,   218.,   245.,   272.,   257.,
      290.,   323.,   356.,   323.,   362.,   401.,   440.,   300.,   328.,
      356.,   384.,   339.,   378.,   417.,   456.,   687.,   750.,   813.,
      876.,   840.,   912.,   984.,   1056.,  993.,   1074.,  1155.,  1236.,
      837.,   894.,   951.,   1008.,  789.,   858.,   927.,   996.,   1452.,
      1560.,  1668.,  1776.,  1605.,  1722.,  1839.,  1956.,  1758.,  1884.,
      2010.,  2136.,  1407.,  1494.,  1581.,  1668.,  1239.,  1338.,  1437.,
      1536.,  2217.,  2370.,  2523.,  2676.,  2370.,  2532.,  2694.,  2856.,
      2523.,  2694.,  2865.,  3036.,  1977.,  2094.,  2211.,  2328.,  1689.,
      1818.,  1947.,  2076.,  2982.,  3180.,  3378.,  3576.,  3135.,  3342.,
      3549.,  3756.,  3288.,  3504.,  3720.,  3936.,  2547.,  2694.,  2841.,
      2988.,  1952.,  2048.,  2144.,  2240.,  3275.,  3422.,  3569.,  3716.,
      3413.,  3566.,  3719.,  3872.,  3551.,  3710.,  3869.,  4028.,  2636.,
      2744.,  2852.,  2960.,  1160.,  1296.,  1432.,  1568.,  2171.,  2378.,
      2585.,  2792.,  2237.,  2450.,  2663.,  2876.,  2303.,  2522.,  2741.,
      2960.,  1860.,  2008.,  2156.,  2304.,  3039.,  3258.,  3477.,  3696.,
      5277.,  5610.,  5943.,  6276.,  5430.,  5772.,  6114.,  6456.,  5583.,
      5934.,  6285.,  6636.,  4257.,  4494.,  4731.,  4968.,  3489.,  3738.,
      3987.,  4236.,  6042.,  6420.,  6798.,  7176.,  6195.,  6582.,  6969.,
      7356.,  6348.,  6744.,  7140.,  7536.,  4827.,  5094.,  5361.,  5628.,
      3939.,  4218.,  4497.,  4776.,  6807.,  7230.,  7653.,  8076.,  6960.,
      7392.,  7824.,  8256.,  7113.,  7554.,  7995.,  8436.,  5397.,  5694.,
      5991.,  6288.,  4389.,  4698.,  5007.,  5316.,  7572.,  8040.,  8508.,
      8976.,  7725.,  8202.,  8679.,  9156.,  7878.,  8364.,  8850.,  9336.,
      5967.,  6294.,  6621.,  6948.,  4472.,  4688.,  4904.,  5120.,  7415.,
      7742.,  8069.,  8396.,  7553.,  7886.,  8219.,  8552.,  7691.,  8030.,
      8369.,  8708.,  5636.,  5864.,  6092.,  6320.,  2240.,  2496.,  2752.,
      3008.,  4151.,  4538.,  4925.,  5312.,  4217.,  4610.,  5003.,  5396.,
      4283.,  4682.,  5081.,  5480.,  3420.,  3688.,  3956.,  4224.,  5739.,
      6138.,  6537.,  6936.,  9867.,  10470., 11073., 11676., 10020., 10632.,
      11244., 11856., 10173., 10794., 11415., 12036., 7677.,  8094.,  8511.,
      8928.,  6189.,  6618.,  7047.,  7476.,  10632., 11280., 11928., 12576.,
      10785., 11442., 12099., 12756., 10938., 11604., 12270., 12936., 8247.,
      8694.,  9141.,  9588.,  6639.,  7098.,  7557.,  8016.,  11397., 12090.,
      12783., 13476., 11550., 12252., 12954., 13656., 11703., 12414., 13125.,
      13836., 8817.,  9294.,  9771.,  10248., 7089.,  7578.,  8067.,  8556.,
      12162., 12900., 13638., 14376., 12315., 13062., 13809., 14556., 12468.,
      13224., 13980., 14736., 9387.,  9894.,  10401., 10908., 6992.,  7328.,
      7664.,  8000.,  11555., 12062., 12569., 13076., 11693., 12206., 12719.,
      13232., 11831., 12350., 12869., 13388., 8636.,  8984.,  9332.,  9680.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    2.,    3.,    4.,    7.,    10.,   13.,   16.,   22.,   28.,
      34.,   40.,   33.,   38.,   43.,   48.,   27.,   30.,   33.,   36.,
      17.,   22.,   27.,   32.,   68.,   80.,   92.,   104.,  161.,  182.,
      203.,  224.,  168.,  184.,  200.,  216.,  117.,  126.,  135.,  144.,
      84.,   96.,   108.,  120.,  255.,  282.,  309.,  336.,  525.,  570.,
      615.,  660.,  477.,  510.,  543.,  576.,  306.,  324.,  342.,  360.,
      201.,  222.,  243.,  264.,  525.,  570.,  615.,  660.,  984.,  1056.,
      1128., 1200., 819.,  870.,  921.,  972.,  495.,  522.,  549.,  576.,
      305.,  322.,  339.,  356.,  716.,  752.,  788.,  824.,  1241., 1298.,
      1355., 1412., 960.,  1000., 1040., 1080., 549.,  570.,  591.,  612.,
      250.,  260.,  270.,  280.,  565.,  586.,  607.,  628.,  949.,  982.,
      1015., 1048., 711.,  734.,  757.,  780.,  396.,  408.,  420.,  432.,
      13.,   26.,   39.,   52.,   79.,   106.,  133.,  160.,  202.,  244.,
      286.,  328.,  201.,  230.,  259.,  288.,  135.,  150.,  165.,  180.,
      185.,  214.,  243.,  272.,  500.,  560.,  620.,  680.,  953.,  1046.,
      1139., 1232., 792.,  856.,  920.,  984.,  477.,  510.,  543.,  576.,
      552.,  600.,  648.,  696.,  1335., 1434., 1533., 1632., 2361., 2514.,
      2667., 2820., 1845., 1950., 2055., 2160., 1062., 1116., 1170., 1224.,
      669.,  726.,  783.,  840.,  1605., 1722., 1839., 1956., 2820., 3000.,
      3180., 3360., 2187., 2310., 2433., 2556., 1251., 1314., 1377., 1440.,
      761.,  802.,  843.,  884.,  1724., 1808., 1892., 1976., 2897., 3026.,
      3155., 3284., 2160., 2248., 2336., 2424., 1197., 1242., 1287., 1332.,
      550.,  572.,  594.,  616.,  1213., 1258., 1303., 1348., 1993., 2062.,
      2131., 2200., 1455., 1502., 1549., 1596., 792.,  816.,  840.,  864.,
      25.,   50.,   75.,   100.,  151.,  202.,  253.,  304.,  382.,  460.,
      538.,  616.,  369.,  422.,  475.,  528.,  243.,  270.,  297.,  324.,
      353.,  406.,  459.,  512.,  932.,  1040., 1148., 1256., 1745., 1910.,
      2075., 2240., 1416., 1528., 1640., 1752., 837.,  894.,  951.,  1008.,
      1020., 1104., 1188., 1272., 2415., 2586., 2757., 2928., 4197., 4458.,
      4719., 4980., 3213., 3390., 3567., 3744., 1818., 1908., 1998., 2088.,
      1137., 1230., 1323., 1416., 2685., 2874., 3063., 3252., 4656., 4944.,
      5232., 5520., 3555., 3750., 3945., 4140., 2007., 2106., 2205., 2304.,
      1217., 1282., 1347., 1412., 2732., 2864., 2996., 3128., 4553., 4754.,
      4955., 5156., 3360., 3496., 3632., 3768., 1845., 1914., 1983., 2052.,
      850.,  884.,  918.,  952.,  1861., 1930., 1999., 2068., 3037., 3142.,
      3247., 3352., 2199., 2270., 2341., 2412., 1188., 1224., 1260., 1296.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      540.,   660.,    780.,    900.,    1348.,  1552.,   1756.,   1960.,
      1864.,  2116.,   2368.,   2620.,   2380.,  2680.,   2980.,   3280.,
      2244.,  2460.,   2676.,   2892.,   2460.,  2760.,   3060.,   3360.,
      5073.,  5559.,   6045.,   6531.,   6279.,  6837.,   7395.,   7953.,
      7485.,  8115.,   8745.,   9375.,   6360.,  6804.,   7248.,   7692.,
      6000.,  6540.,   7080.,   7620.,   11103., 11949.,  12795.,  13641.,
      12309., 13227.,  14145.,  15063.,  13515., 14505.,  15495.,  16485.,
      10860., 11544.,  12228.,  12912.,  9540.,  10320.,  11100.,  11880.,
      17133., 18339.,  19545.,  20751.,  18339., 19617.,  20895.,  22173.,
      19545., 20895.,  22245.,  23595.,  15360., 16284.,  17208.,  18132.,
      13080., 14100.,  15120.,  16140.,  23163., 24729.,  26295.,  27861.,
      24369., 26007.,  27645.,  29283.,  25575., 27285.,  28995.,  30705.,
      19860., 21024.,  22188.,  23352.,  15260., 16020.,  16780.,  17540.,
      25636., 26800.,  27964.,  29128.,  26728., 27940.,  29152.,  30364.,
      27820., 29080.,  30340.,  31600.,  20676., 21532.,  22388.,  23244.,
      8940.,  10020.,  11100.,  12180.,  16828., 18472.,  20116.,  21760.,
      17344., 19036.,  20728.,  22420.,  17860., 19600.,  21340.,  23080.,
      14484., 15660.,  16836.,  18012.,  23700., 25440.,  27180.,  28920.,
      41253., 43899.,  46545.,  49191.,  42459., 45177.,  47895.,  50613.,
      43665., 46455.,  49245.,  52035.,  33360., 35244.,  37128.,  39012.,
      27240., 29220.,  31200.,  33180.,  47283., 50289.,  53295.,  56301.,
      48489., 51567.,  54645.,  57723.,  49695., 52845.,  55995.,  59145.,
      37860., 39984.,  42108.,  44232.,  30780., 33000.,  35220.,  37440.,
      53313., 56679.,  60045.,  63411.,  54519., 57957.,  61395.,  64833.,
      55725., 59235.,  62745.,  66255.,  42360., 44724.,  47088.,  49452.,
      34320., 36780.,  39240.,  41700.,  59343., 63069.,  66795.,  70521.,
      60549., 64347.,  68145.,  71943.,  61755., 65625.,  69495.,  73365.,
      46860., 49464.,  52068.,  54672.,  35180., 36900.,  38620.,  40340.,
      58396., 61000.,  63604.,  66208.,  59488., 62140.,  64792.,  67444.,
      60580., 63280.,  65980.,  68680.,  44436., 46252.,  48068.,  49884.,
      17340., 19380.,  21420.,  23460.,  32308., 35392.,  38476.,  41560.,
      32824., 35956.,  39088.,  42220.,  33340., 36520.,  39700.,  42880.,
      26724., 28860.,  30996.,  33132.,  44940., 48120.,  51300.,  54480.,
      77433., 82239.,  87045.,  91851.,  78639., 83517.,  88395.,  93273.,
      79845., 84795.,  89745.,  94695.,  60360., 63684.,  67008.,  70332.,
      48480., 51900.,  55320.,  58740.,  83463., 88629.,  93795.,  98961.,
      84669., 89907.,  95145.,  100383., 85875., 91185.,  96495.,  101805.,
      64860., 68424.,  71988.,  75552.,  52020., 55680.,  59340.,  63000.,
      89493., 95019.,  100545., 106071., 90699., 96297.,  101895., 107493.,
      91905., 97575.,  103245., 108915., 69360., 73164.,  76968.,  80772.,
      55560., 59460.,  63360.,  67260.,  95523., 101409., 107295., 113181.,
      96729., 102687., 108645., 114603., 97935., 103965., 109995., 116025.,
      73860., 77904.,  81948.,  85992.,  55100., 57780.,  60460.,  63140.,
      91156., 95200.,  99244.,  103288., 92248., 96340.,  100432., 104524.,
      93340., 97480.,  101620., 105760., 68196., 70972.,  73748.,  76524.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,     11.,    17.,    23.,    40.,    60.,    80.,    100.,   137.,
      179.,   221.,   263.,   228.,   264.,   300.,   336.,   193.,   215.,
      237.,   259.,   100.,   136.,   172.,   208.,   452.,   540.,   628.,
      716.,   1120.,  1276.,  1432.,  1588.,  1212.,  1332.,  1452.,  1572.,
      860.,   928.,   996.,   1064.,  573.,   663.,   753.,   843.,   1812.,
      2016.,  2220.,  2424.,  3813.,  4155.,  4497.,  4839.,  3528.,  3780.,
      4032.,  4284.,  2289.,  2427.,  2565.,  2703.,  1491.,  1653.,  1815.,
      1977.,  3936.,  4284.,  4632.,  4980.,  7431.,  7989.,  8547.,  9105.,
      6228.,  6624.,  7020.,  7416.,  3783.,  3993.,  4203.,  4413.,  2332.,
      2464.,  2596.,  2728.,  5492.,  5772.,  6052.,  6332.,  9544.,  9988.,
      10432., 10876., 7404.,  7716.,  8028.,  8340.,  4244.,  4408.,  4572.,
      4736.,  1931.,  2009.,  2087.,  2165.,  4372.,  4536.,  4700.,  4864.,
      7355.,  7613.,  7871.,  8129.,  5520.,  5700.,  5880.,  6060.,  3079.,
      3173.,  3267.,  3361.,  77.,    179.,   281.,   383.,   568.,   780.,
      992.,   1204.,  1505.,  1835.,  2165.,  2495.,  1524.,  1752.,  1980.,
      2208.,  1033.,  1151.,  1269.,  1387.,  1396.,  1624.,  1852.,  2080.,
      3812.,  4284.,  4756.,  5228.,  7312.,  8044.,  8776.,  9508.,  6108.,
      6612.,  7116.,  7620.,  3692.,  3952.,  4212.,  4472.,  4245.,  4623.,
      5001.,  5379.,  10308., 11088., 11868., 12648., 18285., 19491., 20697.,
      21903., 14328., 15156., 15984., 16812., 8265.,  8691.,  9117.,  9543.,
      5163.,  5613.,  6063.,  6513.,  12432., 13356., 14280., 15204., 21903.,
      23325., 24747., 26169., 17028., 18000., 18972., 19944., 9759.,  10257.,
      10755., 11253., 5932.,  6256.,  6580.,  6904.,  13460., 14124., 14788.,
      15452., 22648., 23668., 24688., 25708., 16908., 17604., 18300., 18996.,
      9380.,  9736.,  10092., 10448., 4307.,  4481.,  4655.,  4829.,  9508.,
      9864.,  10220., 10576., 15635., 16181., 16727., 17273., 11424., 11796.,
      12168., 12540., 6223.,  6413.,  6603.,  6793.,  149.,   347.,   545.,
      743.,   1096.,  1500.,  1904.,  2308.,  2873.,  3491.,  4109.,  4727.,
      2820.,  3240.,  3660.,  4080.,  1873.,  2087.,  2301.,  2515.,  2692.,
      3112.,  3532.,  3952.,  7172.,  8028.,  8884.,  9740.,  13504., 14812.,
      16120., 17428., 11004., 11892., 12780., 13668., 6524.,  6976.,  7428.,
      7880.,  7917.,  8583.,  9249.,  9915.,  18804., 20160., 21516., 22872.,
      32757., 34827., 36897., 38967., 25128., 26532., 27936., 29340., 14241.,
      14955., 15669., 16383., 8835.,  9573.,  10311., 11049., 20928., 22428.,
      23928., 25428., 36375., 38661., 40947., 43233., 27828., 29376., 30924.,
      32472., 15735., 16521., 17307., 18093., 9532.,  10048., 10564., 11080.,
      21428., 22476., 23524., 24572., 35752., 37348., 38944., 40540., 26412.,
      27492., 28572., 29652., 14516., 15064., 15612., 16160., 6683.,  6953.,
      7223.,  7493.,  14644., 15192., 15740., 16288., 23915., 24749., 25583.,
      26417., 17328., 17892., 18456., 19020., 9367.,  9653.,  9939.,  10225.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3928.,   4856.,   5784.,   6712.,   10076.,  11660.,  13244.,  14828.,
      14156.,  16124.,  18092.,  20060.,  18236.,  20588.,  22940.,  25292.,
      17336.,  19032.,  20728.,  22424.,  18684.,  21036.,  23388.,  25740.,
      38910.,  42726.,  46542.,  50358.,  48486.,  52878.,  57270.,  61662.,
      58062.,  63030.,  67998.,  72966.,  49548.,  53052.,  56556.,  60060.,
      46764.,  51036.,  55308.,  59580.,  86790.,  93486.,  100182., 106878.,
      96366.,  103638., 110910., 118182., 105942., 113790., 121638., 129486.,
      85308.,  90732.,  96156.,  101580., 74844.,  81036.,  87228.,  93420.,
      134670., 144246., 153822., 163398., 144246., 154398., 164550., 174702.,
      153822., 164550., 175278., 186006., 121068., 128412., 135756., 143100.,
      102924., 111036., 119148., 127260., 182550., 195006., 207462., 219918.,
      192126., 205158., 218190., 231222., 201702., 215310., 228918., 242526.,
      156828., 166092., 175356., 184620., 120664., 126712., 132760., 138808.,
      202844., 212108., 221372., 230636., 211532., 221180., 230828., 240476.,
      220220., 230252., 240284., 250316., 163768., 170584., 177400., 184216.,
      70168.,  78776.,  87384.,  95992.,  132476., 145580., 158684., 171788.,
      136556., 150044., 163532., 177020., 140636., 154508., 168380., 182252.,
      114296., 123672., 133048., 142424., 187164., 201036., 214908., 228780.,
      326190., 347286., 368382., 389478., 335766., 357438., 379110., 400782.,
      345342., 367590., 389838., 412086., 264108., 279132., 294156., 309180.,
      215244., 231036., 246828., 262620., 374070., 398046., 422022., 445998.,
      383646., 408198., 432750., 457302., 393222., 418350., 443478., 468606.,
      299868., 316812., 333756., 350700., 243324., 261036., 278748., 296460.,
      421950., 448806., 475662., 502518., 431526., 458958., 486390., 513822.,
      441102., 469110., 497118., 525126., 335628., 354492., 373356., 392220.,
      271404., 291036., 310668., 330300., 469830., 499566., 529302., 559038.,
      479406., 509718., 540030., 570342., 488982., 519870., 550758., 581646.,
      371388., 392172., 412956., 433740., 279064., 292792., 306520., 320248.,
      463484., 484268., 505052., 525836., 472172., 493340., 514508., 535676.,
      480860., 502412., 523964., 545516., 352888., 367384., 381880., 396376.,
      136408., 152696., 168984., 185272., 254876., 279500., 304124., 328748.,
      258956., 283964., 308972., 333980., 263036., 288428., 313820., 339212.,
      211256., 228312., 245368., 262424., 355644., 381036., 406428., 431820.,
      613470., 651846., 690222., 728598., 623046., 661998., 700950., 739902.,
      632622., 672150., 711678., 751206., 478668., 505212., 531756., 558300.,
      383724., 411036., 438348., 465660., 661350., 702606., 743862., 785118.,
      670926., 712758., 754590., 796422., 680502., 722910., 765318., 807726.,
      514428., 542892., 571356., 599820., 411804., 441036., 470268., 499500.,
      709230., 753366., 797502., 841638., 718806., 763518., 808230., 852942.,
      728382., 773670., 818958., 864246., 550188., 580572., 610956., 641340.,
      439884., 471036., 502188., 533340., 757110., 804126., 851142., 898158.,
      766686., 814278., 861870., 909462., 776262., 824430., 872598., 920766.,
      585948., 618252., 650556., 682860., 437464., 458872., 480280., 501688.,
      724124., 756428., 788732., 821036., 732812., 765500., 798188., 830876.,
      741500., 774572., 807644., 840716., 542008., 564184., 586360., 608536.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,     70.,     110.,    150.,    260.,    404.,    548.,    692.,
      946.,    1258.,   1570.,   1882.,   1684.,   1956.,   2228.,   2500.,
      1454.,   1622.,   1790.,   1958.,   660.,    932.,    1204.,   1476.,
      3256.,   3928.,   4600.,   5272.,   8300.,   9500.,   10700.,  11900.,
      9176.,   10104.,  11032.,  11960.,  6580.,   7108.,   7636.,   8164.,
      4194.,   4890.,   5586.,   6282.,   13596.,  15180.,  16764.,  18348.,
      28974.,  31638.,  34302.,  36966.,  27084.,  29052.,  31020.,  32988.,
      17682.,  18762.,  19842.,  20922.,  11466.,  12738.,  14010.,  15282.,
      30444.,  33180.,  35916.,  38652.,  57702.,  62094.,  66486.,  70878.,
      48540.,  51660.,  54780.,  57900.,  29562.,  31218.,  32874.,  34530.,
      18228.,  19268.,  20308.,  21348.,  43000.,  45208.,  47416.,  49624.,
      74828.,  78332.,  81836.,  85340.,  58136.,  60600.,  63064.,  65528.,
      33364.,  34660.,  35956.,  37252.,  15174.,  15790.,  16406.,  17022.,
      34388.,  35684.,  36980.,  38276.,  57898.,  59938.,  61978.,  64018.,
      43492.,  44916.,  46340.,  47764.,  24278.,  25022.,  25766.,  26510.,
      510.,    1318.,   2126.,   2934.,   4292.,   5972.,   7652.,   9332.,
      11602.,  14218.,  16834.,  19450.,  11860.,  13668.,  15476.,  17284.,
      8078.,   9014.,   9950.,   10886.,  10836.,  12644.,  14452.,  16260.,
      29752.,  33496.,  37240.,  40984.,  57260.,  63068.,  68876.,  74684.,
      47960.,  51960.,  55960.,  59960.,  29044.,  31108.,  33172.,  35236.,
      33282.,  36282.,  39282.,  42282.,  80988.,  87180.,  93372.,  99564.,
      143886., 153462., 163038., 172614., 112908., 119484., 126060., 132636.,
      65202.,  68586.,  71970.,  75354.,  40554.,  44130.,  47706.,  51282.,
      97836.,  105180., 112524., 119868., 172614., 183918., 195222., 206526.,
      134364., 142092., 149820., 157548., 77082.,  81042.,  85002.,  88962.,
      46836.,  49412.,  51988.,  54564.,  106360., 111640., 116920., 122200.,
      179084., 187196., 195308., 203420., 133784., 139320., 144856., 150392.,
      74260.,  77092.,  79924.,  82756.,  34086.,  35470.,  36854.,  38238.,
      75284.,  78116.,  80948.,  83780.,  123850., 128194., 132538., 136882.,
      90532.,  93492.,  96452.,  99412.,  49334.,  50846.,  52358.,  53870.,
      990.,    2566.,   4142.,   5718.,   8324.,   11540.,  14756.,  17972.,
      22258.,  27178.,  32098.,  37018.,  22036.,  25380.,  28724.,  32068.,
      14702.,  16406.,  18110.,  19814.,  21012.,  24356.,  27700.,  31044.,
      56248.,  63064.,  69880.,  76696.,  106220., 116636., 127052., 137468.,
      86744.,  93816.,  100888., 107960., 51508.,  55108.,  58708.,  62308.,
      62370.,  67674.,  72978.,  78282.,  148380., 159180., 169980., 180780.,
      258798., 275286., 291774., 308262., 198732., 209916., 221100., 232284.,
      112722., 118410., 124098., 129786., 69642.,  75522.,  81402.,  87282.,
      165228., 177180., 189132., 201084., 287526., 305742., 323958., 342174.,
      220188., 232524., 244860., 257196., 124602., 130866., 137130., 143394.,
      75444.,  79556.,  83668.,  87780.,  169720., 178072., 186424., 194776.,
      283340., 296060., 308780., 321500., 209432., 218040., 226648., 235256.,
      115156., 119524., 123892., 128260., 52998.,  55150.,  57302.,  59454.,
      116180., 120548., 124916., 129284., 189802., 196450., 203098., 209746.,
      137572., 142068., 146564., 151060., 74390.,  76670.,  78950.,  81230.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      35.,   74.,   95.,   116.,  137.,  117.,  129.,  246.,  291.,  336.,
      381.,  306.,  291.,  516.,  561.,  606.,  651.,  504.,  453.,  786.,
      831.,  876.,  921.,  702.,  615.,  1056., 1101., 1146., 1191., 900.,
      665.,  1100., 1139., 1178., 1217., 891.,  467.,  830.,  851.,  872.,
      893.,  693.,  1101., 1866., 1911., 1956., 2001., 1494., 1263., 2136.,
      2181., 2226., 2271., 1692., 1425., 2406., 2451., 2496., 2541., 1890.,
      1587., 2676., 2721., 2766., 2811., 2088., 1529., 2504., 2543., 2582.,
      2621., 1899., 899.,  1586., 1607., 1628., 1649., 1269., 2073., 3486.,
      3531., 3576., 3621., 2682., 2235., 3756., 3801., 3846., 3891., 2880.,
      2397., 4026., 4071., 4116., 4161., 3078., 2559., 4296., 4341., 4386.,
      4431., 3276., 2393., 3908., 3947., 3986., 4025., 2907.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    4.,    10.,   16.,   17.,   12.,   9.,    29.,   62.,   83.,
      75.,   48.,   36.,   99.,   192.,  237.,  198.,  120.,  84.,   207.,
      372.,  417.,  330.,  192.,  115.,  263.,  446.,  485.,  365.,  204.,
      91.,   202.,  334.,  358.,  263.,  144.,  17.,   52.,   106.,  112.,
      97.,   60.,   89.,   221.,  398.,  419.,  331.,  192.,  228.,  531.,
      912.,  957.,  726.,  408.,  276.,  639.,  1092., 1137., 858.,  480.,
      291.,  647.,  1070., 1109., 813.,  444.,  203.,  442.,  718.,  742.,
      535.,  288.,  33.,   100.,  202.,  208.,  177.,  108.,  169.,  413.,
      734.,  755.,  587.,  336.,  420.,  963.,  1632., 1677., 1254., 696.,
      468.,  1071., 1812., 1857., 1386., 768.,  467.,  1031., 1694., 1733.,
      1261., 684.,  315.,  682.,  1102., 1126., 807.,  432.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      224.,   496.,   652.,   808.,   964.,   840.,   894.,   1743.,  2085.,
      2427.,  2769.,  2250.,  2118.,  3795.,  4137.,  4479.,  4821.,  3762.,
      3342.,  5847.,  6189.,  6531.,  6873.,  5274.,  4566.,  7899.,  8241.,
      8583.,  8925.,  6786.,  5048.,  8380.,  8680.,  8980.,  9280.,  6816.,
      3392.,  6112.,  6268.,  6424.,  6580.,  5160.,  8238.,  14055., 14397.,
      14739., 15081., 11322., 9462.,  16107., 16449., 16791., 17133., 12834.,
      10686., 18159., 18501., 18843., 19185., 14346., 11910., 20211., 20553.,
      20895., 21237., 15858., 11672., 19180., 19480., 19780., 20080., 14592.,
      6560.,  11728., 11884., 12040., 12196., 9480.,  15582., 26367., 26709.,
      27051., 27393., 20394., 16806., 28419., 28761., 29103., 29445., 21906.,
      18030., 30471., 30813., 31155., 31497., 23418., 19254., 32523., 32865.,
      33207., 33549., 24930., 18296., 29980., 30280., 30580., 30880., 22368.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,     22.,   59.,    101.,   114.,   83.,    52.,    184.,  412.,
      568.,   528.,  344.,   237.,   678.,   1347.,  1689.,  1434., 879.,
      597.,   1494., 2715.,  3057.,  2442.,  1431.,  856.,   1968., 3352.,
      3652.,  2760., 1548.,  689.,   1534.,  2543.,  2729.,  2010., 1103.,
      101.,   342.,  731.,   773.,   690.,   435.,   628.,   1592., 2908.,
      3064.,  2448., 1432.,  1677.,  3942.,  6819.,  7161.,  5466., 3087.,
      2037.,  4758., 8187.,  8529.,  6474.,  3639.,  2200.,  4912., 8152.,
      8452.,  6216., 3404.,  1553.,  3390.,  5519.,  5705.,  4122., 2223.,
      197.,   662.,  1403.,  1445.,  1266.,  787.,   1204.,  3000., 5404.,
      5560.,  4368., 2520.,  3117.,  7206.,  12291., 12633., 9498., 5295.,
      3477.,  8022., 13659., 14001., 10506., 5847.,  3544.,  7856., 12952.,
      13252., 9672., 5260.,  2417.,  5246.,  8495.,  8681.,  6234., 3343.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1576.,   3596.,   4796.,   5996.,   7196.,   6344.,   6612.,   13062.,
      15726.,  18390.,  21054.,  17220.,  16116.,  29046.,  31710.,  34374.,
      37038.,  29028.,  25620.,  45030.,  47694.,  50358.,  53022.,  40836.,
      35124.,  61014.,  63678.,  66342.,  69006.,  52644.,  39304.,  65372.,
      67724.,  70076.,  72428.,  53288.,  25768.,  46796.,  47996.,  49196.,
      50396.,  39752.,  63636.,  108966., 111630., 114294., 116958., 88068.,
      73140.,  124950., 127614., 130278., 132942., 99876.,  82644.,  140934.,
      143598., 146262., 148926., 111684., 92148.,  156918., 159582., 162246.,
      164910., 123492., 91144.,  150044., 152396., 154748., 157100., 114344.,
      49960.,  89996.,  91196.,  92396.,  93596.,  73160.,  120660., 204870.,
      207534., 210198., 212862., 158916., 130164., 220854., 223518., 226182.,
      228846., 170724., 139668., 236838., 239502., 242166., 244830., 182532.,
      149172., 252822., 255486., 258150., 260814., 194340., 142984., 234716.,
      237068., 239420., 241772., 175400.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    140.,   394.,    706.,    828.,    614.,    340.,   1288.,
      2972.,  4172.,  3944.,   2596.,   1698.,   4980.,   10038., 12702.,
      10884., 6714.,  4482.,   11316.,  20694.,  23358.,  18756., 11034.,
      6596.,  15208., 25964.,  28316.,  21448.,  12052.,  5358.,  11948.,
      19834., 21298., 15708.,  8630.,   670.,    2444.,   5386.,  5698.,
      5180.,  3302.,  4692.,   12040.,  22172.,  23372.,  18792., 11044.,
      12834., 30324., 52662.,  55326.,  42372.,  23994.,  15618., 36660.,
      63318., 65982., 50244.,  28314.,  17092.,  38248.,  63596., 65948.,
      48584., 26644., 12142.,  26540.,  43258.,  44722.,  32348., 17462.,
      1310.,  4748.,  10378.,  10690.,  9532.,   5990.,   9044.,  22792.,
      41372., 42572., 33640.,  19492.,  23970.,  55668.,  95286., 97950.,
      73860., 41274., 26754.,  62004.,  105942., 108606., 81732., 45594.,
      27588., 61288., 101228., 103580., 75720.,  41236.,  18926., 41132.,
      66682., 68146., 48988.,  26294.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      52.,   70.,   118.,  148.,  154.,  190.,  190.,  232.,  226.,  274.,
      200.,  234.,  213.,  258.,  420.,  492.,  501.,  582.,  582.,  672.,
      663.,  762.,  543.,  612.,  501.,  582.,  906.,  1032., 987.,  1122.,
      1068., 1212., 1149., 1302., 903.,  1008., 789.,  906.,  1392., 1572.,
      1473., 1662., 1554., 1752., 1635., 1842., 1263., 1404., 1077., 1230.,
      1878., 2112., 1959., 2202., 2040., 2292., 2121., 2382., 1623., 1800.,
      1216., 1330., 2026., 2200., 2098., 2278., 2170., 2356., 2242., 2434.,
      1652., 1782., 772.,  934.,  1414., 1660., 1450., 1702., 1486., 1744.,
      1522., 1786., 1208., 1386., 1941., 2202., 3336., 3732., 3417., 3822.,
      3498., 3912., 3579., 4002., 2703., 2988., 2229., 2526., 3822., 4272.,
      3903., 4362., 3984., 4452., 4065., 4542., 3063., 3384., 2517., 2850.,
      4308., 4812., 4389., 4902., 4470., 4992., 4551., 5082., 3423., 3780.,
      2805., 3174., 4794., 5352., 4875., 5442., 4956., 5532., 5037., 5622.,
      3783., 4176., 2800., 3058., 4618., 5008., 4690., 5086., 4762., 5164.,
      4834., 5242., 3524., 3798., 1492., 1798., 2710., 3172., 2746., 3214.,
      2782., 3256., 2818., 3298., 2216., 2538., 3669., 4146., 6252., 6972.,
      6333., 7062., 6414., 7152., 6495., 7242., 4863., 5364., 3957., 4470.,
      6738., 7512., 6819., 7602., 6900., 7692., 6981., 7782., 5223., 5760.,
      4245., 4794., 7224., 8052., 7305., 8142., 7386., 8232., 7467., 8322.,
      5583., 6156., 4533., 5118., 7710., 8592., 7791., 8682., 7872., 8772.,
      7953., 8862., 5943., 6552., 4384., 4786., 7210., 7816., 7282., 7894.,
      7354., 7972., 7426., 8050., 5396., 5814.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    2.,    5.,    8.,    14.,   20.,   23.,   32.,   27.,   34.,
      20.,   24.,   12.,   18.,   44.,   58.,   100.,  124.,  136.,  166.,
      128.,  150.,  84.,   96.,   57.,   72.,   165.,  198.,  330.,  384.,
      411.,  474.,  351.,  396.,  216.,  240.,  141.,  168.,  357.,  414.,
      654.,  744.,  735.,  834.,  591.,  660.,  348.,  384.,  208.,  230.,
      480.,  526.,  820.,  892.,  892.,  970.,  676.,  730.,  380.,  408.,
      169.,  182.,  377.,  404.,  626.,  668.,  671.,  716.,  495.,  526.,
      272.,  288.,  17.,   34.,   69.,   104.,  158.,  212.,  167.,  224.,
      155.,  194.,  100.,  120.,  140.,  178.,  364.,  442.,  676.,  796.,
      712.,  838.,  576.,  662.,  340.,  384.,  393.,  456.,  933.,  1062.,
      1626., 1824., 1707., 1914., 1311., 1452., 744.,  816.,  477.,  552.,
      1125., 1278., 1950., 2184., 2031., 2274., 1551., 1716., 876.,  960.,
      528.,  582.,  1184., 1294., 1972., 2140., 2044., 2218., 1508., 1626.,
      828.,  888.,  377.,  406.,  825.,  884.,  1346., 1436., 1391., 1484.,
      1007., 1070., 544.,  576.,  33.,   66.,   133.,  200.,  302.,  404.,
      311.,  416.,  283.,  354.,  180.,  216.,  268.,  338.,  684.,  826.,
      1252., 1468., 1288., 1510., 1024., 1174., 596.,  672.,  729.,  840.,
      1701., 1926., 2922., 3264., 3003., 3354., 2271., 2508., 1272., 1392.,
      813.,  936.,  1893., 2142., 3246., 3624., 3327., 3714., 2511., 2772.,
      1404., 1536., 848.,  934.,  1888., 2062., 3124., 3388., 3196., 3466.,
      2340., 2522., 1276., 1368., 585.,  630.,  1273., 1364., 2066., 2204.,
      2111., 2252., 1519., 1614., 816.,  864.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      344.,   480.,   818.,   1046.,  1094.,  1370.,  1370.,  1694.,  1646.,
      2018.,  1480.,  1744.,  1524.,  1872.,  3063.,  3621.,  3693.,  4323.,
      4323.,  5025.,  4953.,  5727.,  4092.,  4632.,  3756.,  4392.,  6843.,
      7833.,  7473.,  8535.,  8103.,  9237.,  8733.,  9939.,  6900.,  7728.,
      5988.,  6912.,  10623., 12045., 11253., 12747., 11883., 13449., 12513.,
      14151., 9708.,  10824., 8220.,  9432.,  14403., 16257., 15033., 16959.,
      15663., 17661., 16293., 18363., 12516., 13920., 9416.,  10320., 15722.,
      17102., 16286., 17714., 16850., 18326., 17414., 18938., 12856., 13888.,
      5816.,  7104.,  10754., 12710., 11030., 13034., 11306., 13358., 11582.,
      13682., 9256.,  10672., 14916., 16992., 25743., 28893., 26373., 29595.,
      27003., 30297., 27633., 30999., 20940., 23208., 17148., 19512., 29523.,
      33105., 30153., 33807., 30783., 34509., 31413., 35211., 23748., 26304.,
      19380., 22032., 33303., 37317., 33933., 38019., 34563., 38721., 35193.,
      39423., 26556., 29400., 21612., 24552., 37083., 41529., 37713., 42231.,
      38343., 42933., 38973., 43635., 29364., 32496., 21800., 23856., 36026.,
      39134., 36590., 39746., 37154., 40358., 37718., 40970., 27544., 29728.,
      11288., 13728., 20690., 24374., 20966., 24698., 21242., 25022., 21518.,
      25346., 17032., 19600., 28308., 32112., 48423., 54165., 49053., 54867.,
      49683., 55569., 50313., 56271., 37788., 41784., 30540., 34632., 52203.,
      58377., 52833., 59079., 53463., 59781., 54093., 60483., 40596., 44880.,
      32772., 37152., 55983., 62589., 56613., 63291., 57243., 63993., 57873.,
      64695., 43404., 47976., 35004., 39672., 59763., 66801., 60393., 67503.,
      61023., 68205., 61653., 68907., 46212., 51072., 34184., 37392., 56330.,
      61166., 56894., 61778., 57458., 62390., 58022., 63002., 42232., 45568.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,     11.,    28.,    48.,    85.,    127.,   151.,   217.,   188.,
      240.,   143.,   173.,   70.,    114.,   288.,   392.,   686.,   866.,
      962.,   1190.,  928.,   1096.,  618.,   710.,   387.,   501.,   1164.,
      1416.,  2379.,  2793.,  3009.,  3495.,  2604.,  2952.,  1617.,  1803.,
      1035.,  1245.,  2652.,  3096.,  4899.,  5601.,  5529.,  6303.,  4476.,
      5016.,  2649.,  2931.,  1582.,  1754.,  3664.,  4024.,  6278.,  6842.,
      6842.,  7454.,  5200.,  5624.,  2930.,  3150.,  1301.,  1403.,  2908.,
      3120.,  4837.,  5167.,  5191.,  5545.,  3836.,  4080.,  2111.,  2237.,
      101.,   235.,   476.,   752.,   1141.,  1567.,  1207.,  1657.,  1148.,
      1456.,  751.,   909.,   1030.,  1330.,  2720.,  3336.,  5102.,  6050.,
      5378.,  6374.,  4384.,  5064.,  2602.,  2950.,  2979.,  3477.,  7116.,
      8136.,  12459., 14025., 13089., 14727., 10092., 11208., 5745.,  6315.,
      3627.,  4221.,  8604.,  9816.,  14979., 16833., 15609., 17535., 11964.,
      13272., 6777.,  7443.,  4078.,  4506.,  9168.,  10040., 15302., 16634.,
      15866., 17246., 11728., 12664., 6450.,  6926.,  2933.,  3163.,  6428.,
      6896.,  10501., 11215., 10855., 11593., 7868.,  8368.,  4255.,  4509.,
      197.,   459.,   924.,   1456.,  2197.,  3007.,  2263.,  3097.,  2108.,
      2672.,  1359.,  1645.,  1990.,  2546.,  5152.,  6280.,  9518.,  11234.,
      9794.,  11558., 7840.,  9032.,  4586.,  5190.,  5571.,  6453.,  13068.,
      14856., 22539., 25257., 23169., 25959., 17580., 19464., 9873.,  10827.,
      6219.,  7197.,  14556., 16536., 25059., 28065., 25689., 28767., 19452.,
      21528., 10905., 11955., 6574.,  7258.,  14672., 16056., 24326., 26426.,
      24890., 27038., 18256., 19704., 9970.,  10702., 4565.,  4923.,  9948.,
      10672., 16165., 17263., 16519., 17641., 11900., 12656., 6399.,  6781.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2472.,   3528.,   6052.,   7828.,   8212.,   10372.,  10372.,  12916.,
      12532.,  15460.,  11368.,  13448.,  11484.,  14220.,  23334.,  27726.,
      28302.,  33270.,  33270.,  38814.,  38238.,  44358.,  31740.,  36012.,
      29052.,  34092.,  53142.,  60990.,  58110.,  66534.,  63078.,  72078.,
      68046.,  77622.,  53916.,  60492.,  46620.,  53964.,  82950.,  94254.,
      87918.,  99798.,  92886.,  105342., 97854.,  110886., 76092.,  84972.,
      64188.,  73836.,  112758., 127518., 117726., 133062., 122694., 138606.,
      127662., 144150., 98268.,  109452., 74088.,  81288.,  123844., 134836.,
      128308., 139684., 132772., 144532., 137236., 149380., 101416., 109640.,
      45096.,  55368.,  83812.,  99412.,  85972.,  101956., 88132.,  104500.,
      90292.,  107044., 72424.,  83720.,  116892., 133452., 202182., 227310.,
      207150., 232854., 212118., 238398., 217086., 243942., 164796., 182892.,
      134460., 153324., 231990., 260574., 236958., 266118., 241926., 271662.,
      246894., 277206., 186972., 207372., 152028., 173196., 261798., 293838.,
      266766., 299382., 271734., 304926., 276702., 310470., 209148., 231852.,
      169596., 193068., 291606., 327102., 296574., 332646., 301542., 338190.,
      306510., 343734., 231324., 256332., 172008., 188424., 284548., 309364.,
      289012., 314212., 293476., 319060., 297940., 323908., 217768., 235208.,
      87720.,  107208., 161572., 190996., 163732., 193540., 165892., 196084.,
      168052., 198628., 133480., 153992., 222300., 252684., 381030., 426894.,
      385998., 432438., 390966., 437982., 395934., 443526., 297852., 329772.,
      239868., 272556., 410838., 460158., 415806., 465702., 420774., 471246.,
      425742., 476790., 320028., 354252., 257436., 292428., 440646., 493422.,
      445614., 498966., 450582., 504510., 455550., 510054., 342204., 378732.,
      275004., 312300., 470454., 526686., 475422., 532230., 480390., 537774.,
      485358., 543318., 364380., 403212., 269928., 295560., 445252., 483892.,
      449716., 488740., 454180., 493588., 458644., 498436., 334120., 360776.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,     70.,     180.,    324.,    578.,    890.,    1082.,   1586.,
      1396.,   1796.,   1078.,   1310.,   460.,    796.,    2056.,   2856.,
      5044.,   6436.,   7204.,   8980.,   7048.,   8360.,   4732.,   5452.,
      2826.,   3714.,   8700.,   10668.,  18006.,  21246.,  22974.,  26790.,
      20028.,  22764.,  12498.,  13962.,  7914.,   9570.,   20412.,  23916.,
      37878.,  43422.,  42846.,  48966.,  34812.,  39084.,  20658.,  22890.,
      12332.,  13692.,  28616.,  31464.,  49108.,  53572.,  53572.,  58420.,
      40776.,  44136.,  23004.,  24748.,  10206.,  11014.,  22836.,  24516.,
      38018.,  40634.,  40826.,  43634.,  30196.,  32132.,  16630.,  17630.,
      670.,    1734.,   3508.,   5700.,   8642.,   12026.,  9146.,   12722.,
      8820.,   11268.,  5814.,   7070.,   7884.,   10268.,  21000.,  25896.,
      39604.,  47140.,  41764.,  49684.,  34184.,  39592.,  20348.,  23116.,
      23178.,  27138.,  55548.,  63660.,  97494.,  109950., 102462., 115494.,
      79164.,  88044.,  45138.,  49674.,  28266.,  32994.,  67260.,  76908.,
      117366., 132126., 122334., 137670., 93948.,  104364., 53298.,  58602.,
      32044.,  35452.,  72136.,  79080.,  120532., 131140., 124996., 135988.,
      92488.,  99944.,  50908.,  54700.,  23134.,  24966.,  50740.,  54468.,
      82946.,  88634.,  85754.,  91634.,  62196.,  66180.,  33654.,  35678.,
      1310.,   3398.,   6836.,   11076.,  16706.,  23162.,  17210.,  23858.,
      16244.,  20740.,  10550.,  12830.,  15308.,  19740.,  39944.,  48936.,
      74164.,  87844.,  76324.,  90388.,  61320.,  70824.,  35964.,  40780.,
      43530.,  50562.,  102396., 116652., 176982., 198654., 181950., 204198.,
      138300., 153324., 77778.,  85386.,  48618.,  56418.,  114108., 129900.,
      196854., 220830., 201822., 226374., 153084., 169644., 85938.,  94314.,
      51756.,  57212.,  115656., 126696., 191956., 208708., 196420., 213556.,
      144200., 155752., 78812.,  84652.,  36062.,  38918.,  78644.,  84420.,
      127874., 136634., 130682., 139634., 94196.,  100228., 50678.,  53726.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      86.,    104.,   122.,   140.,   206.,   236.,   266.,   296.,   272.,
      308.,   344.,   380.,   338.,   380.,   422.,   464.,   404.,   452.,
      500.,   548.,   366.,   400.,   434.,   468.,   381.,   426.,   471.,
      516.,   768.,   840.,   912.,   984.,   921.,   1002.,  1083.,  1164.,
      1074.,  1164.,  1254.,  1344.,  1227.,  1326.,  1425.,  1524.,  1017.,
      1086.,  1155.,  1224.,  921.,   1002.,  1083.,  1164.,  1686.,  1812.,
      1938.,  2064.,  1839.,  1974.,  2109.,  2244.,  1992.,  2136.,  2280.,
      2424.,  2145.,  2298.,  2451.,  2604.,  1701.,  1806.,  1911.,  2016.,
      1461.,  1578.,  1695.,  1812.,  2604.,  2784.,  2964.,  3144.,  2757.,
      2946.,  3135.,  3324.,  2910.,  3108.,  3306.,  3504.,  3063.,  3270.,
      3477.,  3684.,  2385.,  2526.,  2667.,  2808.,  2001.,  2154.,  2307.,
      2460.,  3522.,  3756.,  3990.,  4224.,  3675.,  3918.,  4161.,  4404.,
      3828.,  4080.,  4332.,  4584.,  3981.,  4242.,  4503.,  4764.,  3069.,
      3246.,  3423.,  3600.,  2318.,  2432.,  2546.,  2660.,  3878.,  4052.,
      4226.,  4400.,  4016.,  4196.,  4376.,  4556.,  4154.,  4340.,  4526.,
      4712.,  4292.,  4484.,  4676.,  4868.,  3174.,  3304.,  3434.,  3564.,
      1382.,  1544.,  1706.,  1868.,  2582.,  2828.,  3074.,  3320.,  2648.,
      2900.,  3152.,  3404.,  2714.,  2972.,  3230.,  3488.,  2780.,  3044.,
      3308.,  3572.,  2238.,  2416.,  2594.,  2772.,  3621.,  3882.,  4143.,
      4404.,  6276.,  6672.,  7068.,  7464.,  6429.,  6834.,  7239.,  7644.,
      6582.,  6996.,  7410.,  7824.,  6735.,  7158.,  7581.,  8004.,  5121.,
      5406.,  5691.,  5976.,  4161.,  4458.,  4755.,  5052.,  7194.,  7644.,
      8094.,  8544.,  7347.,  7806.,  8265.,  8724.,  7500.,  7968.,  8436.,
      8904.,  7653.,  8130.,  8607.,  9084.,  5805.,  6126.,  6447.,  6768.,
      4701.,  5034.,  5367.,  5700.,  8112.,  8616.,  9120.,  9624.,  8265.,
      8778.,  9291.,  9804.,  8418.,  8940.,  9462.,  9984.,  8571.,  9102.,
      9633.,  10164., 6489.,  6846.,  7203.,  7560.,  5241.,  5610.,  5979.,
      6348.,  9030.,  9588.,  10146., 10704., 9183.,  9750.,  10317., 10884.,
      9336.,  9912.,  10488., 11064., 9489.,  10074., 10659., 11244., 7173.,
      7566.,  7959.,  8352.,  5342.,  5600.,  5858.,  6116.,  8846.,  9236.,
      9626.,  10016., 8984.,  9380.,  9776.,  10172., 9122.,  9524.,  9926.,
      10328., 9260.,  9668.,  10076., 10484., 6774.,  7048.,  7322.,  7596.,
      2678.,  2984.,  3290.,  3596.,  4958.,  5420.,  5882.,  6344.,  5024.,
      5492.,  5960.,  6428.,  5090.,  5564.,  6038.,  6512.,  5156.,  5636.,
      6116.,  6596.,  4110.,  4432.,  4754.,  5076.,  6861.,  7338.,  7815.,
      8292.,  11784., 12504., 13224., 13944., 11937., 12666., 13395., 14124.,
      12090., 12828., 13566., 14304., 12243., 12990., 13737., 14484., 9225.,
      9726.,  10227., 10728., 7401.,  7914.,  8427.,  8940.,  12702., 13476.,
      14250., 15024., 12855., 13638., 14421., 15204., 13008., 13800., 14592.,
      15384., 13161., 13962., 14763., 15564., 9909.,  10446., 10983., 11520.,
      7941.,  8490.,  9039.,  9588.,  13620., 14448., 15276., 16104., 13773.,
      14610., 15447., 16284., 13926., 14772., 15618., 16464., 14079., 14934.,
      15789., 16644., 10593., 11166., 11739., 12312., 8481.,  9066.,  9651.,
      10236., 14538., 15420., 16302., 17184., 14691., 15582., 16473., 17364.,
      14844., 15744., 16644., 17544., 14997., 15906., 16815., 17724., 11277.,
      11886., 12495., 13104., 8366.,  8768.,  9170.,  9572.,  13814., 14420.,
      15026., 15632., 13952., 14564., 15176., 15788., 14090., 14708., 15326.,
      15944., 14228., 14852., 15476., 16100., 10374., 10792., 11210., 11628.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    2.,    3.,    4.,    7.,    10.,   13.,   16.,   22.,   28.,
      34.,   40.,   37.,   46.,   55.,   64.,   47.,   54.,   61.,   68.,
      36.,   40.,   44.,   48.,   18.,   24.,   30.,   36.,   74.,   88.,
      102.,  116.,  176.,  200.,  224.,  248.,  242.,  272.,  302.,  332.,
      234.,  256.,  278.,  300.,  156.,  168.,  180.,  192.,  99.,   114.,
      129.,  144.,  297.,  330.,  363.,  396.,  606.,  660.,  714.,  768.,
      759.,  822.,  885.,  948.,  657.,  702.,  747.,  792.,  408.,  432.,
      456.,  480.,  255.,  282.,  309.,  336.,  657.,  714.,  771.,  828.,
      1218., 1308., 1398., 1488., 1371., 1470., 1569., 1668., 1113., 1182.,
      1251., 1320., 660.,  696.,  732.,  768.,  394.,  416.,  438.,  460.,
      914.,  960.,  1006., 1052., 1568., 1640., 1712., 1784., 1706., 1784.,
      1862., 1940., 1298., 1352., 1406., 1460., 732.,  760.,  788.,  816.,
      325.,  338.,  351.,  364.,  727.,  754.,  781.,  808.,  1210., 1252.,
      1294., 1336., 1297., 1342., 1387., 1432., 959.,  990.,  1021., 1052.,
      528.,  544.,  560.,  576.,  17.,   34.,   51.,   68.,   103.,  138.,
      173.,  208.,  262.,  316.,  370.,  424.,  277.,  334.,  391.,  448.,
      271.,  310.,  349.,  388.,  180.,  200.,  220.,  240.,  242.,  280.,
      318.,  356.,  650.,  728.,  806.,  884.,  1232., 1352., 1472., 1592.,
      1298., 1424., 1550., 1676., 1066., 1152., 1238., 1324., 636.,  680.,
      724.,  768.,  723.,  786.,  849.,  912.,  1737., 1866., 1995., 2124.,
      3054., 3252., 3450., 3648., 3207., 3414., 3621., 3828., 2481., 2622.,
      2763., 2904., 1416., 1488., 1560., 1632., 879.,  954.,  1029., 1104.,
      2097., 2250., 2403., 2556., 3666., 3900., 4134., 4368., 3819., 4062.,
      4305., 4548., 2937., 3102., 3267., 3432., 1668., 1752., 1836., 1920.,
      1002., 1056., 1110., 1164., 2258., 2368., 2478., 2588., 3776., 3944.,
      4112., 4280., 3914., 4088., 4262., 4436., 2898., 3016., 3134., 3252.,
      1596., 1656., 1716., 1776., 725.,  754.,  783.,  812.,  1591., 1650.,
      1709., 1768., 2602., 2692., 2782., 2872., 2689., 2782., 2875., 2968.,
      1951., 2014., 2077., 2140., 1056., 1088., 1120., 1152., 33.,   66.,
      99.,   132.,  199.,  266.,  333.,  400.,  502.,  604.,  706.,  808.,
      517.,  622.,  727.,  832.,  495.,  566.,  637.,  708.,  324.,  360.,
      396.,  432.,  466.,  536.,  606.,  676.,  1226., 1368., 1510., 1652.,
      2288., 2504., 2720., 2936., 2354., 2576., 2798., 3020., 1898., 2048.,
      2198., 2348., 1116., 1192., 1268., 1344., 1347., 1458., 1569., 1680.,
      3177., 3402., 3627., 3852., 5502., 5844., 6186., 6528., 5655., 6006.,
      6357., 6708., 4305., 4542., 4779., 5016., 2424., 2544., 2664., 2784.,
      1503., 1626., 1749., 1872., 3537., 3786., 4035., 4284., 6114., 6492.,
      6870., 7248., 6267., 6654., 7041., 7428., 4761., 5022., 5283., 5544.,
      2676., 2808., 2940., 3072., 1610., 1696., 1782., 1868., 3602., 3776.,
      3950., 4124., 5984., 6248., 6512., 6776., 6122., 6392., 6662., 6932.,
      4498., 4680., 4862., 5044., 2460., 2552., 2644., 2736., 1125., 1170.,
      1215., 1260., 2455., 2546., 2637., 2728., 3994., 4132., 4270., 4408.,
      4081., 4222., 4363., 4504., 2943., 3038., 3133., 3228., 1584., 1632.,
      1680., 1728.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      584.,    720.,    856.,    992.,    1462.,   1690.,   1918.,   2146.,
      1978.,   2254.,   2530.,   2806.,   2494.,   2818.,   3142.,   3466.,
      3010.,   3382.,   3754.,   4126.,   2760.,   3024.,   3288.,   3552.,
      2784.,   3132.,   3480.,   3828.,   5703.,   6261.,   6819.,   7377.,
      6909.,   7539.,   8169.,   8799.,   8115.,   8817.,   9519.,   10221.,
      9321.,   10095.,  10869.,  11643.,  7776.,   8316.,   8856.,   9396.,
      7032.,   7668.,   8304.,   8940.,   12939.,  13929.,  14919.,  15909.,
      14145.,  15207.,  16269.,  17331.,  15351.,  16485.,  17619.,  18753.,
      16557.,  17763.,  18969.,  20175.,  13176.,  14004.,  14832.,  15660.,
      11280.,  12204.,  13128.,  14052.,  20175.,  21597.,  23019.,  24441.,
      21381.,  22875.,  24369.,  25863.,  22587.,  24153.,  25719.,  27285.,
      23793.,  25431.,  27069.,  28707.,  18576.,  19692.,  20808.,  21924.,
      15528.,  16740.,  17952.,  19164.,  27411.,  29265.,  31119.,  32973.,
      28617.,  30543.,  32469.,  34395.,  29823.,  31821.,  33819.,  35817.,
      31029.,  33099.,  35169.,  37239.,  23976.,  25380.,  26784.,  28188.,
      18152.,  19056.,  19960.,  20864.,  30406.,  31786.,  33166.,  34546.,
      31498.,  32926.,  34354.,  35782.,  32590.,  34066.,  35542.,  37018.,
      33682.,  35206.,  36730.,  38254.,  24936.,  25968.,  27000.,  28032.,
      10664.,  11952.,  13240.,  14528.,  20038.,  21994.,  23950.,  25906.,
      20554.,  22558.,  24562.,  26566.,  21070.,  23122.,  25174.,  27226.,
      21586.,  23686.,  25786.,  27886.,  17448.,  18864.,  20280.,  21696.,
      28272.,  30348.,  32424.,  34500.,  49119.,  52269.,  55419.,  58569.,
      50325.,  53547.,  56769.,  59991.,  51531.,  54825.,  58119.,  61413.,
      52737.,  56103.,  59469.,  62835.,  40176.,  42444.,  44712.,  46980.,
      32520.,  34884.,  37248.,  39612.,  56355.,  59937.,  63519.,  67101.,
      57561.,  61215.,  64869.,  68523.,  58767.,  62493.,  66219.,  69945.,
      59973.,  63771.,  67569.,  71367.,  45576.,  48132.,  50688.,  53244.,
      36768.,  39420.,  42072.,  44724.,  63591.,  67605.,  71619.,  75633.,
      64797.,  68883.,  72969.,  77055.,  66003.,  70161.,  74319.,  78477.,
      67209.,  71439.,  75669.,  79899.,  50976.,  53820.,  56664.,  59508.,
      41016.,  43956.,  46896.,  49836.,  70827.,  75273.,  79719.,  84165.,
      72033.,  76551.,  81069.,  85587.,  73239.,  77829.,  82419.,  87009.,
      74445.,  79107.,  83769.,  88431.,  56376.,  59508.,  62640.,  65772.,
      42056.,  44112.,  46168.,  48224.,  69718.,  72826.,  75934.,  79042.,
      70810.,  73966.,  77122.,  80278.,  71902.,  75106.,  78310.,  81514.,
      72994.,  76246.,  79498.,  82750.,  53448.,  55632.,  57816.,  60000.,
      20744.,  23184.,  25624.,  28064.,  38614.,  42298.,  45982.,  49666.,
      39130.,  42862.,  46594.,  50326.,  39646.,  43426.,  47206.,  50986.,
      40162.,  43990.,  47818.,  51646.,  32136.,  34704.,  37272.,  39840.,
      53760.,  57564.,  61368.,  65172.,  92535.,  98277.,  104019., 109761.,
      93741.,  99555.,  105369., 111183., 94947.,  100833., 106719., 112605.,
      96153.,  102111., 108069., 114027., 72576.,  76572.,  80568.,  84564.,
      58008.,  62100.,  66192.,  70284.,  99771.,  105945., 112119., 118293.,
      100977., 107223., 113469., 119715., 102183., 108501., 114819., 121137.,
      103389., 109779., 116169., 122559., 77976.,  82260.,  86544.,  90828.,
      62256.,  66636.,  71016.,  75396.,  107007., 113613., 120219., 126825.,
      108213., 114891., 121569., 128247., 109419., 116169., 122919., 129669.,
      110625., 117447., 124269., 131091., 83376.,  87948.,  92520.,  97092.,
      66504.,  71172.,  75840.,  80508.,  114243., 121281., 128319., 135357.,
      115449., 122559., 129669., 136779., 116655., 123837., 131019., 138201.,
      117861., 125115., 132369., 139623., 88776.,  93636.,  98496.,  103356.,
      65960.,  69168.,  72376.,  75584.,  109030., 113866., 118702., 123538.,
      110122., 115006., 119890., 124774., 111214., 116146., 121078., 126010.,
      112306., 117286., 122266., 127246., 81960.,  85296.,  88632.,  91968.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,     11.,    17.,    23.,    40.,    60.,    80.,    100.,   137.,
      179.,   221.,   263.,   251.,   317.,   383.,   449.,   336.,   388.,
      440.,   492.,   263.,   293.,   323.,   353.,   106.,   150.,   194.,
      238.,   496.,   600.,   704.,   808.,   1234.,  1414.,  1594.,  1774.,
      1750.,  1978.,  2206.,  2434.,  1728.,  1896.,  2064.,  2232.,  1166.,
      1258.,  1350.,  1442.,  687.,   801.,   915.,   1029.,  2136.,  2388.,
      2640.,  2892.,  4443.,  4857.,  5271.,  5685.,  5649.,  6135.,  6621.,
      7107.,  4944.,  5292.,  5640.,  5988.,  3093.,  3279.,  3465.,  3651.,
      1911.,  2121.,  2331.,  2541.,  4968.,  5412.,  5856.,  6300.,  9267.,
      9969.,  10671., 11373., 10473., 11247., 12021., 12795., 8544.,  9084.,
      9624.,  10164., 5085.,  5367.,  5649.,  5931.,  3034.,  3206.,  3378.,
      3550.,  7056.,  7416.,  7776.,  8136.,  12130., 12694., 13258., 13822.,
      13222., 13834., 14446., 15058., 10080., 10504., 10928., 11352., 5694.,
      5914.,  6134.,  6354.,  2525.,  2627.,  2729.,  2831.,  5656.,  5868.,
      6080.,  6292.,  9425.,  9755.,  10085., 10415., 10115., 10469., 10823.,
      11177., 7488.,  7732.,  7976.,  8220.,  4127.,  4253.,  4379.,  4505.,
      101.,   235.,   369.,   503.,   744.,   1020.,  1296.,  1572.,  1961.,
      2387.,  2813.,  3239.,  2075.,  2525.,  2975.,  3425.,  2064.,  2372.,
      2680.,  2988.,  1383.,  1541.,  1699.,  1857.,  1834.,  2134.,  2434.,
      2734.,  4976.,  5592.,  6208.,  6824.,  9490.,  10438., 11386., 12334.,
      10006., 11002., 11998., 12994., 8256.,  8936.,  9616.,  10296., 4942.,
      5290.,  5638.,  5986.,  5583.,  6081.,  6579.,  7077.,  13464., 14484.,
      15504., 16524., 23739., 25305., 26871., 28437., 24945., 26583., 28221.,
      29859., 19344., 20460., 21576., 22692., 11061., 11631., 12201., 12771.,
      6807.,  7401.,  7995.,  8589.,  16296., 17508., 18720., 19932., 28563.,
      30417., 32271., 34125., 29769., 31695., 33621., 35547., 22944., 24252.,
      25560., 26868., 13053., 13719., 14385., 15051., 7834.,  8262.,  8690.,
      9118.,  17680., 18552., 19424., 20296., 29602., 30934., 32266., 33598.,
      30694., 32074., 33454., 34834., 22752., 23688., 24624., 25560., 12542.,
      13018., 13494., 13970., 5693.,  5923.,  6153.,  6383.,  12504., 12972.,
      13440., 13908., 20465., 21179., 21893., 22607., 21155., 21893., 22631.,
      23369., 15360., 15860., 16360., 16860., 8319.,  8573.,  8827.,  9081.,
      197.,   459.,   721.,   983.,   1448.,  1980.,  2512.,  3044.,  3785.,
      4595.,  5405.,  6215.,  3899.,  4733.,  5567.,  6401.,  3792.,  4356.,
      4920.,  5484.,  2503.,  2789.,  3075.,  3361.,  3562.,  4118.,  4674.,
      5230.,  9456.,  10584., 11712., 12840., 17746., 19462., 21178., 22894.,
      18262., 20026., 21790., 23554., 14784., 15976., 17168., 18360., 8718.,
      9322.,  9926.,  10530., 10479., 11361., 12243., 13125., 24792., 26580.,
      28368., 30156., 43035., 45753., 48471., 51189., 44241., 47031., 49821.,
      52611., 33744., 35628., 37512., 39396., 19029., 19983., 20937., 21891.,
      11703., 12681., 13659., 14637., 27624., 29604., 31584., 33564., 47859.,
      50865., 53871., 56877., 49065., 52143., 55221., 58299., 37344., 39420.,
      41496., 43572., 21021., 22071., 23121., 24171., 12634., 13318., 14002.,
      14686., 28304., 29688., 31072., 32456., 47074., 49174., 51274., 53374.,
      48166., 50314., 52462., 54610., 35424., 36872., 38320., 39768., 19390.,
      20122., 20854., 21586., 8861.,  9219.,  9577.,  9935.,  19352., 20076.,
      20800., 21524., 31505., 32603., 33701., 34799., 32195., 33317., 34439.,
      35561., 23232., 23988., 24744., 25500., 12511., 12893., 13275., 13657.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4264.,    5320.,    6376.,    7432.,    10964.,   12740.,   14516.,
      16292.,   15044.,   17204.,   19364.,   21524.,   19124.,   21668.,
      24212.,   26756.,   23204.,   26132.,   29060.,   31988.,   21416.,
      23496.,   25576.,   27656.,   21228.,   23964.,   26700.,   29436.,
      43878.,   48270.,   52662.,   57054.,   53454.,   58422.,   63390.,
      68358.,   63030.,   68574.,   74118.,   79662.,   72606.,   78726.,
      84846.,   90966.,   60780.,   65052.,   69324.,   73596.,   54924.,
      59964.,   65004.,   70044.,   101334.,  109182.,  117030.,  124878.,
      110910.,  119334.,  127758.,  136182.,  120486.,  129486.,  138486.,
      147486.,  130062.,  139638.,  149214.,  158790.,  103692.,  110268.,
      116844.,  123420.,  88620.,   95964.,   103308.,  110652.,  158790.,
      170094.,  181398.,  192702.,  168366.,  180246.,  192126.,  204006.,
      177942.,  190398.,  202854.,  215310.,  187518.,  200550.,  213582.,
      226614.,  146604.,  155484.,  164364.,  173244.,  122316.,  131964.,
      141612.,  151260.,  216246.,  231006.,  245766.,  260526.,  225822.,
      241158.,  256494.,  271830.,  235398.,  251310.,  267222.,  283134.,
      244974.,  261462.,  277950.,  294438.,  189516.,  200700.,  211884.,
      223068.,  143656.,  150856.,  158056.,  165256.,  240788.,  251780.,
      262772.,  273764.,  249476.,  260852.,  272228.,  283604.,  258164.,
      269924.,  281684.,  293444.,  266852.,  278996.,  291140.,  303284.,
      197672.,  205896.,  214120.,  222344.,  83752.,   94024.,   104296.,
      114568.,  157844.,  173444.,  189044.,  204644.,  161924.,  177908.,
      193892.,  209876.,  166004.,  182372.,  198740.,  215108.,  170084.,
      186836.,  203588.,  220340.,  137768.,  149064.,  160360.,  171656.,
      223404.,  239964.,  256524.,  273084.,  388614.,  413742.,  438870.,
      463998.,  398190.,  423894.,  449598.,  475302.,  407766.,  434046.,
      460326.,  486606.,  417342.,  444198.,  471054.,  497910.,  318252.,
      336348.,  354444.,  372540.,  257100.,  275964.,  294828.,  313692.,
      446070.,  474654.,  503238.,  531822.,  455646.,  484806.,  513966.,
      543126.,  465222.,  494958.,  524694.,  554430.,  474798.,  505110.,
      535422.,  565734.,  361164.,  381564.,  401964.,  422364.,  290796.,
      311964.,  333132.,  354300.,  503526.,  535566.,  567606.,  599646.,
      513102.,  545718.,  578334.,  610950.,  522678.,  555870.,  589062.,
      622254.,  532254.,  566022.,  599790.,  633558.,  404076.,  426780.,
      449484.,  472188.,  324492.,  347964.,  371436.,  394908.,  560982.,
      596478.,  631974.,  667470.,  570558.,  606630.,  642702.,  678774.,
      580134.,  616782.,  653430.,  690078.,  589710.,  626934.,  664158.,
      701382.,  446988.,  471996.,  497004.,  522012.,  333736.,  350152.,
      366568.,  382984.,  553556.,  578372.,  603188.,  628004.,  562244.,
      587444.,  612644.,  637844.,  570932.,  596516.,  622100.,  647684.,
      579620.,  605588.,  631556.,  657524.,  424616.,  442056.,  459496.,
      476936.,  163240.,  182728.,  202216.,  221704.,  304724.,  334148.,
      363572.,  392996.,  308804.,  338612.,  368420.,  398228.,  312884.,
      343076.,  373268.,  403460.,  316964.,  347540.,  378116.,  408692.,
      254120.,  274632.,  295144.,  315656.,  425580.,  455964.,  486348.,
      516732.,  733350.,  779214.,  825078.,  870942.,  742926.,  789366.,
      835806.,  882246.,  752502.,  799518.,  846534.,  893550.,  762078.,
      809670.,  857262.,  904854.,  575724.,  607644.,  639564.,  671484.,
      459276.,  491964.,  524652.,  557340.,  790806.,  840126.,  889446.,
      938766.,  800382.,  850278.,  900174.,  950070.,  809958.,  860430.,
      910902.,  961374.,  819534.,  870582.,  921630.,  972678.,  618636.,
      652860.,  687084.,  721308.,  492972.,  527964.,  562956.,  597948.,
      848262.,  901038.,  953814.,  1006590., 857838.,  911190.,  964542.,
      1017894., 867414.,  921342.,  975270.,  1029198., 876990.,  931494.,
      985998.,  1040502., 661548.,  698076.,  734604.,  771132.,  526668.,
      563964.,  601260.,  638556.,  905718.,  961950.,  1018182., 1074414.,
      915294.,  972102.,  1028910., 1085718., 924870.,  982254.,  1039638.,
      1097022., 934446.,  992406.,  1050366., 1108326., 704460.,  743292.,
      782124.,  820956.,  523816.,  549448.,  575080.,  600712.,  866324.,
      904964.,  943604.,  982244.,  875012.,  914036.,  953060.,  992084.,
      883700.,  923108.,  962516.,  1001924., 892388.,  932180.,  971972.,
      1011764., 651560.,  678216.,  704872.,  731528.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,     70.,     110.,    150.,    260.,    404.,    548.,    692.,
      946.,    1258.,   1570.,   1882.,   1834.,   2338.,   2842.,   3346.,
      2532.,   2932.,   3332.,   3732.,   2006.,   2238.,   2470.,   2702.,
      700.,    1036.,   1372.,   1708.,   3592.,   4392.,   5192.,   5992.,
      9188.,   10580.,  11972.,  13364.,  13268.,  15044.,  16820.,  18596.,
      13256.,  14568.,  15880.,  17192.,  9004.,   9724.,   10444.,  11164.,
      5082.,   5970.,   6858.,   7746.,   16140.,  18108.,  20076.,  22044.,
      33942.,  37182.,  40422.,  43662.,  43518.,  47334.,  51150.,  54966.,
      38316.,  41052.,  43788.,  46524.,  24066.,  25530.,  26994.,  28458.,
      14778.,  16434.,  18090.,  19746.,  38604.,  42108.,  45612.,  49116.,
      72246.,  77790.,  83334.,  88878.,  81822.,  87942.,  94062.,  100182.,
      66924.,  71196.,  75468.,  79740.,  39906.,  42138.,  44370.,  46602.,
      23804.,  25164.,  26524.,  27884.,  55432.,  58280.,  61128.,  63976.,
      95396.,  99860.,  104324., 108788., 104084., 108932., 113780., 118628.,
      79432.,  82792.,  86152.,  89512.,  44908.,  46652.,  48396.,  50140.,
      19902.,  20710.,  21518.,  22326.,  44612.,  46292.,  47972.,  49652.,
      74386.,  77002.,  79618.,  82234.,  79882.,  82690.,  85498.,  88306.,
      59172.,  61108.,  63044.,  64980.,  32630.,  33630.,  34630.,  35630.,
      670.,    1734.,   2798.,   3862.,   5636.,   7828.,   10020.,  12212.,
      15154.,  18538.,  21922.,  25306.,  16042.,  19618.,  23194.,  26770.,
      16100.,  18548.,  20996.,  23444.,  10838.,  12094.,  13350.,  14606.,
      14268.,  16652.,  19036.,  21420.,  38920.,  43816.,  48712.,  53608.,
      74468.,  82004.,  89540.,  97076.,  78548.,  86468.,  94388.,  102308.,
      64968.,  70376.,  75784.,  81192.,  38956.,  41724.,  44492.,  47260.,
      43866.,  47826.,  51786.,  55746.,  105996., 114108., 122220., 130332.,
      187158., 199614., 212070., 224526., 196734., 209766., 222798., 235830.,
      152748., 161628., 170508., 179388., 87426.,  91962.,  96498.,  101034.,
      53562.,  58290.,  63018.,  67746.,  128460., 138108., 147756., 157404.,
      225462., 240222., 254982., 269742., 235038., 250374., 265710., 281046.,
      181356., 191772., 202188., 212604., 103266., 108570., 113874., 119178.,
      61948.,  65356.,  68764.,  72172.,  139912., 146856., 153800., 160744.,
      234404., 245012., 255620., 266228., 243092., 254084., 265076., 276068.,
      180296., 187752., 195208., 202664., 99436.,  103228., 107020., 110812.,
      45118.,  46950.,  48782.,  50614.,  99140.,  102868., 106596., 110324.,
      162322., 168010., 173698., 179386., 167818., 173698., 179578., 185458.,
      121892., 125876., 129860., 133844., 66038.,  68062.,  70086.,  72110.,
      1310.,   3398.,   5486.,   7574.,   11012.,  15252.,  19492.,  23732.,
      29362.,  35818.,  42274.,  48730.,  30250.,  36898.,  43546.,  50194.,
      29668.,  34164.,  38660.,  43156.,  19670.,  21950.,  24230.,  26510.,
      27836.,  32268.,  36700.,  41132.,  74248.,  83240.,  92232.,  101224.,
      139748., 153428., 167108., 180788., 143828., 157892., 171956., 186020.,
      116680., 126184., 135688., 145192., 68908.,  73724.,  78540.,  83356.,
      82650.,  89682.,  96714.,  103746., 195852., 210108., 224364., 238620.,
      340374., 362046., 383718., 405390., 349950., 372198., 394446., 416694.,
      267180., 282204., 297228., 312252., 150786., 158394., 166002., 173610.,
      92346.,  100146., 107946., 115746., 218316., 234108., 249900., 265692.,
      378678., 402654., 426630., 450606., 388254., 412806., 437358., 461910.,
      295788., 312348., 328908., 345468., 166626., 175002., 183378., 191754.,
      100092., 105548., 111004., 116460., 224392., 235432., 246472., 257512.,
      373412., 390164., 406916., 423668., 382100., 399236., 416372., 433508.,
      281160., 292712., 304264., 315816., 153964., 159804., 165644., 171484.,
      70334.,  73190.,  76046.,  78902.,  153668., 159444., 165220., 170996.,
      250258., 259018., 267778., 276538., 255754., 264706., 273658., 282610.,
      184612., 190644., 196676., 202708., 99446.,  102494., 105542., 108590.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, features, padding,
                                max_input_val);
}